Desenvolupament web dinàmic backend amb PHP
Conceptes¶

Sessió 10: Projecte¶

Objectiu Sessió 10

L'objectiu d'aquesta sessió serà la de desenvolupar un projecte web complert, analitzant des de inici quins són els diferents elements de frontend i backend que cal dissenyar i desenvolupar. A tal efecte, tindrem metodologies que ens ajudaran a assolir eficientment l’objectiu.

Introducció¶

En un projecte de desenvolupament web, el backend és la part que gestiona la lògica interna, el processament de dades i la comunicació amb la base de dades.

A diferència del frontend, que és el que l’usuari veu i amb el qual interactua (HTML, CSS, JS), el backend treballa en segon pla, fent operacions com:

Validar dades enviades per l’usuari.
Guardar, llegir, modificar i esborrar informació en una base de dades.
Gestionar sessions d’usuari i permisos.
Enviar respostes al frontend en format HTML, JSON o altres.

Exemple pràctic

Gestor de Tasques

Definirem els següents elements:

Frontend: l’usuari veu una llista de tasques, pot crear-ne una nova o eliminar-ne una existent.
Backend: rep aquestes peticions i s’encarrega de:
- Validar que l’usuari està identificat.
- Registrar una nova tasca a la base de dades.
- Retornar la nova llista de tasques en format JSON o HTML.

frontend / backend¶

Imagina el vostre projecte de frontend de la sessió 7. Segurament teníeu una interfície d'usuari interactiva construïda amb HTML, CSS i JavaScript. Aquesta interfície permetia als usuaris veure alguna informació o realitzar certes accions directament al navegador.

Ara, pensem en les limitacions d'un projecte purament de frontend:

Persistència de dades: Si l'usuari introduïa alguna dada, un cop tancava el navegador, aquesta informació es perdia. No hi havia cap lloc on guardar-la de manera permanent.
Lògica complexa: Si necessitaveu realitzar operacions complexes amb les dades (per exemple, calcular un preu amb descomptes, validar la informació introduïda per l'usuari segons regles específiques, enviar correus electrònics), fer-ho tot al navegador amb JavaScript podia ser complicat i menys segur.
Accés a recursos protegits: Si la vostra aplicació necessitava accedir a informació sensible o a altres serveis (per exemple, una base de dades amb informació d'usuaris, una API d'un altre servei), fer-ho directament des del navegador seria un risc de seguretat molt gran.

Aquí és on entra en joc el Projecte Backend. El backend és la part "invisible" per a l'usuari final, però és la columna vertebral que permet que la vostra aplicació sigui dinàmica, segura i pugui gestionar dades de manera persistent.

Concepte Pràctic:

Un projecte de backend en PHP (en el context del vostre projecte) serà un conjunt de codi que s'executarà en un servidor. Aquest codi s'encarregarà de:

Rebre peticions del frontend: Quan l'usuari interactua amb la vostra aplicació de frontend (per exemple, fa clic en un botó, envia un formulari), el frontend farà una petició (normalment a través d'HTTP) al vostre servidor backend.
Processar la petició: El vostre codi PHP al backend rebrà aquesta petició i executarà la lògica necessària per respondre-hi. Aquesta lògica pot incloure:
- Validació de dades: Comprovar que la informació enviada pel frontend sigui correcta i compleixi les regles del vostre negoci.
- Accés a la base de dades: Llegir, escriure, modificar o eliminar informació de la base de dades segons la petició.
- Càlculs i lògica de negoci: Realitzar operacions complexes amb les dades.
- Comunicació amb altres serveis: Interactuar amb altres aplicacions o serveis a través d'APIs.
- Gestió de la sessió: Verificar si l'usuari està autenticat i mantenir la seva "sessió" activa.
Enviar una resposta al frontend: Un cop processada la petició, el backend enviarà una resposta al frontend. Aquesta resposta pot ser:
- Dades (per exemple, informació d'usuaris, resultats d'una cerca).
- Un missatge d'èxit o error.
- Una redirecció a una altra pàgina.

Exemple

Exemple concret aplicat al vostre projecte de la sessió 7

Imaginem que a la sessió 7 vau crear un formulari per afegir tasques a una llista. Amb només frontend, aquestes tasques només existien mentre la pàgina estava oberta.

Amb un backend en PHP, podríeu fer el següent:

Quan l'usuari omple el formulari i fa clic a "Afegir tasca" al frontend (JavaScript), aquest JavaScript faria una petició (per exemple, utilitzant fetch o XMLHttpRequest) a una URL específica del vostre servidor backend (per exemple, /api/tasques). La petició inclouria la descripció de la nova tasca.
El vostre codi PHP al backend (en aquesta URL /api/tasques) rebria aquesta petició.
El codi PHP validaria que la descripció de la tasca no estigui buida.
El codi PHP connectaria amb la vostra base de dades i insertaria una nova fila a la taula de "tasques" amb la descripció proporcionada.
El codi PHP enviaria una resposta al frontend (per exemple, un codi d'estat 201 Created) indicant que la tasca s'ha afegit correctament.
El JavaScript al frontend, en rebre la resposta, podria actualitzar la llista de tasques mostrant la nova tasca (potser fent una altra petició al backend per obtenir la llista actualitzada).

D'aquesta manera, la informació de les tasques es guarda de manera permanent a la base de dades gràcies al backend en PHP.

Concretem doncs:

Frontend (La "cara visible" de l'aplicació)

Definició: El frontend, també conegut com a "client-side", és la part de l'aplicació web amb la qual l'usuari interactua directament. És tot allò que veiem a la pantalla: el disseny, els textos, les imatges, els botons, els menús, etc.
Responsabilitats: La principal responsabilitat del frontend és presentar la informació a l'usuari d'una manera atractiva i funcional, i permetre'ls interactuar amb l'aplicació. Això inclou:
- Estructura i contingut: Organitzar la informació utilitzant HTML.
- Estil i aparença: Donar un aspecte visual atractiu amb CSS.
- Interactivitat i dinamisme: Afegir comportament i funcionalitats interactives amb JavaScript.
- Comunicació amb el backend: Enviar peticions al backend (per exemple, quan un usuari envia un formulari o fa clic en un botó) i rebre les respostes per mostrar-les a l'usuari.
- Experiència d'usuari (UX) i Interfície d'Usuari (UI): Assegurar que l'aplicació sigui fàcil d'utilitzar, intuïtiva i ofereixi una bona experiència.
Tecnologies principals:
- HTML (HyperText Markup Language): S'utilitza per definir l'estructura i el significat del contingut web.
- CSS (Cascading Style Sheets): S'encarrega de l'estil visual de la pàgina (colors, fonts, disseny, etc.).
- JavaScript: Un llenguatge de programació que permet afegir interactivitat i funcionalitats dinàmiques al navegador.
- Frameworks i llibreries de JavaScript: Com React, Angular, Vue.js, que faciliten la construcció d'aplicacions web complexes.

Backend (La "part darrere" de l'aplicació)

Definició: El backend, també conegut com a "server-side", és la part de l'aplicació web que s'executa en un servidor i que no és visible per a l'usuari. És la "intel·ligència" i la "base de dades" de l'aplicació.
Responsabilitats: El backend s'encarrega de gestionar la lògica de l'aplicació, les dades i la comunicació amb la base de dades. Això inclou:
- Rebre i processar peticions del frontend: Quan el frontend envia una petició, el backend l'interpreta i executa les accions necessàries.
- Lògica de l'aplicació: Implementar les regles de negoci i les funcionalitats específiques de l'aplicació.
- Gestió de la base de dades: Emmagatzemar, recuperar, modificar i eliminar dades de la base de dades.
- Autenticació i autorització: Verificar la identitat dels usuaris i assegurar que només puguin accedir a les parts de l'aplicació permeses.
- Seguretat: Protegir l'aplicació i les dades de possibles atacs i vulnerabilitats.
- Comunicació amb altres serveis: Interactuar amb altres aplicacions o serveis a través d'APIs.
- Generació de respostes per al frontend: Enviar les dades o la informació necessària al frontend per a que es mostri a l'usuari.
Tecnologies principals:
- PHP: El llenguatge de programació que utilitzareu per construir la lògica del backend.
- Frameworks de PHP: Com Laravel, Symfony, CodeIgniter, que proporcionen una estructura i eines per facilitar el desenvolupament del backend.
- Bases de dades: Com MySQL, PostgreSQL, MongoDB, on s'emmagatzemen les dades de l'aplicació.
- Servidors web: Com Apache o Nginx, que reben les peticions del frontend i les dirigeixen al backend.

En resum:

Frontend = El que l'usuari veu i amb el que interactua. Es centra en la presentació i l'experiència d'usuari.

Backend = El que fa que tot funcioni "per darrere". Es centra en la lògica, la gestió de dades i la seguretat.

De manera pràctica tenim 3 conceptes que podem treballar:

Generació dinàmica d'interfícies HTML + CSS des del backend amb PHP

Normalment, les pàgines HTML i els estils CSS es creen com a fitxers estàtics que el servidor web envia directament al navegador. Però amb PHP, podeu generar aquest codi HTML i CSS de manera dinàmica, és a dir, el contingut i l'aparença de la pàgina es creen "al vol" cada vegada que un usuari la sol·licita, basant-se en diferents factors.
Com funciona:
- Fitxers PHP amb codi HTML i PHP intercalat: Podeu crear fitxers amb extensió .php que continguin tant codi HTML com codi PHP. Les parts de codi PHP estan delimitades per les etiquetes <?php i ?>.
- Lògica PHP per generar HTML: Dins d'aquestes etiquetes PHP, podeu escriure codi que realitzi accions com:
  - Obtenir dades d'una base de dades.
  - Verificar si un usuari ha iniciat sessió.
  - Processar informació d'un formulari.
  - Realitzar càlculs.
  - Basant-se en aquestes accions, el codi PHP pot generar dinàmicament diferents elements HTML (etiquetes, atributs, contingut). Per exemple, un bucle foreach podria generar una llista d'elements HTML a partir d'un array de dades.
- Generació dinàmica de CSS (menys comú però possible): Tot i que el CSS normalment es defineix en fitxers .css separats, també podríeu generar estils CSS dinàmicament amb PHP. Per exemple, podríeu canviar el color de fons d'un element basant-vos en la preferència d'un usuari emmagatzemada a la base de dades o en una sessió. Això es faria generant les regles CSS dins d'una etiqueta <style> al codi HTML generat per PHP.
- Enviament al navegador: Quan un usuari sol·licita un fitxer .php, el servidor web executa el codi PHP que conté. El resultat d'aquesta execució (que serà codi HTML, possiblement amb CSS incrustat) s'envia com a resposta al navegador de l'usuari, que el renderitza i el mostra.
Concepte pràctic per a la vostra intranet:

Imagineu que voleu mostrar un missatge de benvinguda personalitzat a cada usuari que accedeix a la vostra intranet.

Quan un usuari inicia sessió (veurem el concepte de sessió al següent punt), el vostre backend PHP emmagatzema el seu nom d'usuari a la sessió.

Quan aquest usuari accedeix a la pàgina principal de la intranet (index.php), el codi PHP d'aquesta pàgina podria fer el següent:
```
<!DOCTYPE html>
<html>
<head>
    <title>Benvingut a la Intranet</title>
    <link rel="stylesheet" href="estils.css">
</head>
<body>
    <header>
        <h1>Intranet de l'Empresa</h1>
    </header>
    <main>
        <?php
            session_start(); // Important per accedir a les variables de sessió
            if (isset($_SESSION['nom_usuari'])) {
                $nom = $_SESSION['nom_usuari'];
                echo "<p>Benvingut/da, <strong>" . htmlspecialchars($nom) . "</strong>!</p>";
                // Aquí podríeu mostrar més contingut personalitzat per a l'usuari connectat
            } else {
                echo "<p>Si us plau, <a href='login.php'>inicia sessió</a> per accedir al contingut.</p>";
            }
        ?>
        </main>
    <footer>
        <p>© 2025 La meva empresa</p>
    </footer>
</body>
</html>
```
En aquest exemple, el codi PHP verifica si la variable de sessió $_SESSION['nom_usuari'] existeix. Si existeix, mostra un missatge de benvinguda personalitzat. Altrament, demana a l'usuari que iniciï sessió. L'estructura HTML bàsica i l'enllaç al fitxer estils.css són estàtics, però el contingut dins de la secció <main> es genera dinàmicament.
Ús del concepte de sessió amb $_SESSION per gestionar el concepte d'intranet

La sessió en el context web és una manera de mantenir informació sobre un usuari mentre navega per diferents pàgines d'un mateix lloc web. El protocol HTTP és "sense estat", el que significa que cada petició del navegador al servidor es tracta de manera independent, sense recordar les peticions anteriors. Les sessions permeten "recordar" l'usuari i les seves accions entre peticions.
Com funciona amb $_SESSION en PHP:
- Iniciar la sessió: Al principi de cada script PHP on vulgueu accedir o modificar variables de sessió, heu de cridar la funció session_start(). Això fa que PHP intenti recuperar una sessió existent per a l'usuari actual (identificat per una cookie d'identificació de sessió emmagatzemada al seu navegador) o que en creï una de nova si no n'hi ha.
- Emmagatzemar dades a la sessió: Un cop la sessió ha començat, podeu emmagatzemar informació sobre l'usuari en l'array superglobal $_SESSION. Aquesta array és associativa, on podeu guardar parells clau-valor. Per exemple:
```
session_start();
$_SESSION['nom_usuari'] = 'Joan';
$_SESSION['id_usuari'] = 123;
$_SESSION['darrer_acces'] = time();
```
- Accedir a les dades de la sessió: En qualsevol altra pàgina del vostre lloc web (sempre que hi hagi una crida a session_start()), podreu accedir a les variables que heu emmagatzemat a $_SESSION:
```
session_start();
if (isset($_SESSION['nom_usuari'])) {
    echo "Benvingut de nou, " . $_SESSION['nom_usuari'];
}
```
- Destruir la sessió: Quan un usuari tanca la sessió (logout) o quan la sessió expira, podeu eliminar les dades de la sessió o destruir la sessió completament:
```
session_start();
// Per eliminar totes les variables de sessió:
$_SESSION = array();

// Si voleu destruir la sessió completament, també heu d'eliminar la cookie de sessió.
if (ini_get("session.use_cookies")) {
    $params = session_get_cookie_params();
    setcookie(session_name(), '', time() - 42000,
        $params["path"], $params["domain"],
        $params["secure"], $params["httponly"]
    );
}

// Finalment, destruïm la sessió.
session_destroy();
```
Concepte pràctic per a la vostra intranet:

La sessió és fonamental per implementar la funcionalitat d'intranet:
- Autenticació d'usuaris (Login): Quan un usuari introdueix les seves credencials (nom d'usuari i contrasenya) i el backend les verifica (normalment comparant-les amb informació emmagatzemada a la base de dades), si són correctes, es pot emmagatzemar una variable a $_SESSION per indicar que l'usuari ha iniciat sessió (per exemple, $_SESSION['usuari_connectat'] = true;) i possiblement el seu ID o nom d'usuari ($_SESSION['id_usuari'] = 123;).
- Control d'accés: A cada pàgina de la vostra intranet que requereixi que l'usuari estigui autenticat, podreu verificar si la variable $_SESSION['usuari_connectat'] existeix i és true. Si no ho és, podreu redirigir l'usuari a la pàgina de login.
- Personalització: Com hem vist a l'exemple anterior de la generació dinàmica d'HTML, podeu utilitzar les dades emmagatzemades a la sessió (com el nom d'usuari) per personalitzar el contingut que es mostra a l'usuari.
- Mantenir l'estat: Podeu utilitzar la sessió per emmagatzemar altres dades temporals relacionades amb la interacció de l'usuari amb l'aplicació durant la seva sessió (per exemple, preferències de visualització, elements afegits a un carret de compra, etc.).
al Moodle

Podeu veure l’exemple treballat de intranet
Accés a Bases de dades per a la persistència de les dades del projecte web

La persistència de dades es refereix a la capacitat d'emmagatzemar dades de manera que hi puguin accedir i utilitzar-se fins i tot després que l'aplicació s'hagi tancat o el servidor s'hagi reiniciat. Les bases de dades són el mecanisme principal per aconseguir aquesta persistència en aplicacions web.
Com funciona l'accés a bases de dades amb PHP:

PHP proporciona diverses extensions per interactuar amb diferents sistemes de gestió de bases de dades (SGBD), com MySQL, PostgreSQL, SQLite, etc. Una de les maneres més modernes i recomanades és utilitzar PDO (PHP Data Objects).

Utilitzant PDO:
- Establir una connexió: Primer, heu de crear una instància de la classe PDO, especificant el tipus de base de dades, la informació de connexió (host, nom de la base de dades, usuari, contrasenya) i les opcions de configuració. Això es fa dins d'un bloc try...catch per gestionar possibles errors de connexió.
```
$host = 'localhost';
$dbname = 'nom_de_la_vostra_base_de_dades';
$username = 'nom_usuari_bdd';
$password = 'contrasenya_bdd';

try {
    $pdo = new PDO("mysql:host=$host;dbname=$dbname;charset=utf8mb4", $username, $password);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); // Configurar la gestió d'errors
} catch (PDOException $e) {
    die("Error de connexió a la base de dades: " . $e->getMessage());
}
```
- Preparar consultes SQL: Per interactuar amb la base de dades (fer consultes, inserir dades, actualitzar, eliminar), heu de preparar una consulta SQL utilitzant el mètode prepare() de l'objecte PDO. Això és important per prevenir atacs d'injecció SQL.
```
$sql = "SELECT * FROM usuaris WHERE id = :id";
$stmt = $pdo->prepare($sql);
```
- Vincular paràmetres (si n'hi ha): Si la vostra consulta té paràmetres (com :id a l'exemple anterior), heu de vincular els valors utilitzant el mètode bindParam() o bindValue() de l'objecte de la declaració ($stmt).
```
$id_usuari = 10;
$stmt->bindParam(':id', $id_usuari, PDO::PARAM_INT);
```
- Executar la consulta: Un cop preparada i amb els paràmetres vinculats, executeu la consulta amb el mètode execute() de l'objecte de la declaració.
```
$stmt->execute();
```
- Recuperar resultats (per a consultes SELECT): Si la consulta retorna resultats (com un SELECT), podeu utilitzar diversos mètodes de l'objecte de la declaració per obtenir les dades:
- fetch(): Obté la següent fila com un array associatiu, un array numèric o un objecte.
- fetchAll(): Obté totes les files restants com un array d'arrays o d'objectes.
```
while ($fila = $stmt->fetch(PDO::FETCH_ASSOC)) {
    echo "Nom: " . $fila['nom'] . ", Email: " . $fila['email'] . "<br>";
}
```
- Tancar la connexió (opcional): Un cop hàgiu acabat d'interactuar amb la base de dades, podeu tancar la connexió assignant null a l'objecte PDO:
```
$pdo = null;
```
Concepte pràctic per a la persistència de dades del vostre projecte web:

La base de dades serà on emmagatzemareu tota la informació important del vostre projecte:
- Informació dels usuaris de la intranet: Noms d'usuari, contrasenyes (emmagatzemades de manera segura amb hashing), rols, etc.
- Dades específiques del vostre projecte: Qualsevol informació que la vostra aplicació necessiti guardar de manera permanent (per exemple, tasques, productes, articles, etc.).
- Historial d'accions: Registres d'inicis de sessió, modificacions de dades, etc.
Quan el vostre frontend necessiti mostrar o modificar aquesta informació, farà peticions al vostre backend PHP. El backend, al seu torn, utilitzarà les credencials de connexió i les consultes SQL apropiades per interactuar amb la base de dades i obtenir o modificar les dades necessàries. Les dades obtingudes de la base de dades podran ser utilitzades pel backend per generar dinàmicament les respostes HTML que s'enviaran al frontend.

Aquests tres conceptes són fonamentals per construir la lògica del vostre backend en PHP i permetran que la vostra aplicació web sigui dinàmica, gestioni la identitat dels usuaris i persisteixi les dades de manera eficient. Teniu alguna pregunta sobre algun d'aquests punts en concret?

Model de Dades¶

El model de dades és una representació abstracta de l'estructura de les dades que es gestionaran en la vostra aplicació. Defineix les entitats (els objectes principals), els seus atributs (les seves característiques) i les relacions entre aquestes entitats. Un bon model de dades és crucial per a una aplicació eficient i ben organitzada.

Elements clau d'un model de dades:

Entitats: Són els objectes o conceptes principals sobre els quals voleu emmagatzemar informació (per exemple, Usuari, Producte, Comanda, Tasca).
Atributs: Són les propietats o característiques de cada entitat (per exemple, per a l'entitat Usuari: id, nom, email, contrasenya; per a l'entitat Producte: id, nom, descripció, preu).
Relacions: Defineixen com es connecten les diferents entitats entre si (per exemple, un Usuari pot tenir moltes Comandes; una Comanda pot contenir molts Productes). Els tipus de relacions més comuns són:
- Un a un (1:1): Una instància d'una entitat es relaciona amb una única instància d'una altra entitat (per exemple, un Usuari pot tenir un únic Perfil).
- Un a molts (1:N): Una instància d'una entitat es relaciona amb zero o moltes instàncies d'una altra entitat (per exemple, un Usuari pot tenir moltes Comandes).
- Molts a molts (N:M): Moltes instàncies d'una entitat es poden relacionar amb moltes instàncies d'una altra entitat (per exemple, molts Productes poden estar en moltes Comandes).
Sovint, les relacions molts a molts s'implementen amb una taula intermèdia.

Model de Dades i Programació Orientada a Objectes (POO)

La POO ens ofereix eines poderoses per representar i manipular el nostre model de dades de manera coherent i organitzada dins del nostre codi PHP. Els conceptes clau de la POO que s'apliquen al model de dades són les classes i els objectes.

Classes: Una classe és un blueprint o una plantilla per crear objectes. Defineix els atributs (propietats) que tindran els objectes d'aquesta classe i els mètodes (funcions) que podran executar aquests objectes. En el context del model de dades, cada entitat del nostre model es pot representar amb una classe.

Objectes: Un objecte és una instància específica d'una classe. Per exemple, si tenim una classe Usuari, podem crear múltiples objectes d'aquesta classe, cadascun representant un usuari diferent amb els seus propis valors per als atributs (nom, email, etc.).

Com modelar les dades amb POO en PHP:

Definir Classes per a cada Entitat: Per cada entitat identificada en el vostre model de dades, creareu una classe PHP. El nom de la classe normalment es correspon amb el nom de l'entitat (per exemple, Usuari, Producte, Tasca).

Classes model

class Usuari {
    public $id;
    public $nom;
    public $email;
    // ... altres atributs

    public function __construct($id, $nom, $email) {
        $this->id = $id;
        $this->nom = $nom;
        $this->email = $email;
    }

    // Mètodes per interactuar amb l'objecte Usuari (per exemple, obtenir el nom complet)
    public function obtenirNomComplet() {
        return $this->nom; // En un cas real, podria combinar nom i cognoms
    }
}

class Tasca {
    public $id;
    public $titol;
    public $descripcio;
    public $data_creacio;
    public $estat;
    public $id_usuari_assignat; // Clau forana que relaciona amb la classe Usuari

    public function __construct($id, $titol, $descripcio, $data_creacio, $estat, $id_usuari_assignat) {
        $this->id = $id;
        $this->titol = $titol;
        $this->descripcio = $descripcio;
        $this->data_creacio = $data_creacio;
        $this->estat = $estat;
        $this->id_usuari_assignat = $id_usuari_assignat;
    }

    // Mètodes per gestionar l'estat de la tasca
    public function marcarCompletada() {
        $this->estat = 'completada';
    }
}

Representar les Relacions: Les relacions entre les entitats es poden representar de diverses maneres amb POO:

Claus foranes com a atributs: En una relació un a molts (per exemple, un Usuari té moltes Tasques), la classe "molts" (en aquest cas, Tasca) tindrà un atribut que emmagatzema la clau forana que la relaciona amb la classe "un" (id_usuari_assignat a la classe Tasca).
Arrays d'objectes: Una classe "un" podria tenir un atribut que sigui un array d'objectes de la classe "molts". Per exemple, la classe Usuari podria tenir un atribut $tasques que sigui un array d'objectes Tasca associats a aquest usuari. Això sovint es gestiona quan es recuperen les dades de la base de dades.
Classes intermèdies per a relacions molts a molts: Per a relacions molts a molts (per exemple, Producte i Comanda), podríeu tenir una classe addicional (per exemple, LiniaComanda) que contingués referències a ambdós objectes i possiblement atributs addicionals (com la quantitat).

Interacció amb la Base de Dades: La responsabilitat de comunicar-se amb la base de dades per obtenir i guardar objectes del model de dades sovint es delega a altres classes, conegudes com a Repositories o Data Access Objects (DAOs). Aquestes classes contenen la lògica per fer consultes a la base de dades i transformar les files de resultats en objectes del nostre model de dades.

Classes repositori

class UsuariRepository {
    private $pdo;

    public function __construct(PDO $pdo) {
        $this->pdo = $pdo;
    }

    public function obtenirUsuariPerId($id) {
        $stmt = $this->pdo->prepare("SELECT id, nom, email FROM usuaris WHERE id = :id");
        $stmt->bindParam(':id', $id, PDO::PARAM_INT);
        $stmt->execute();
        $fila = $stmt->fetch(PDO::FETCH_ASSOC);

        if ($fila) {
            return new Usuari($fila['id'], $fila['nom'], $fila['email']);
        }
        return null;
    }

    public function guardarUsuari(Usuari $usuari) {
        $stmt = $this->pdo->prepare("INSERT INTO usuaris (nom, email) VALUES (:nom, :email)");
        $stmt->bindParam(':nom', $usuari->nom);
        $stmt->bindParam(':email', $usuari->email);
        return $stmt->execute();
    }
}

// Exemple d'ús:
$usuariRepository = new UsuariRepository($pdo); // $pdo és la vostra connexió a la base de dades
$usuari = $usuariRepository->obtenirUsuariPerId(1);
if ($usuari) {
    echo $usuari->obtenirNomComplet();
}

$nouUsuari = new Usuari(null, 'Anna', 'anna@exemple.com');
$usuariRepository->guardarUsuari($nouUsuari);

Avantatges d'utilitzar POO per al model de dades:

Organització: El codi esdevé més estructurat i fàcil de mantenir. Cada entitat té la seva pròpia classe amb els seus atributs i comportaments associats. Reutilització: Les classes es poden reutilitzar en diferents parts de l'aplicació.
Encapsulament: Els atributs d'un objecte poden estar protegits i només es poden accedir o modificar a través de mètodes definits a la classe, cosa que millora la integritat de les dades.
Abstracció: La complexitat de la representació de les dades s'amaga darrere de la interfície de la classe, facilitant-ne l'ús.
Facilita el mapeig Objecte-Relacional (ORM): Els frameworks de backend sovint utilitzen el concepte de POO per facilitar la interacció entre els objectes del vostre codi i les taules de la base de dades (ORM com Doctrine o Eloquent).

En resum

Utilitzar la POO per modelar les vostres dades implica crear classes PHP que representin les entitats del vostre model de dades, definir els seus atributs com a propietats de la classe i implementar mètodes per interactuar amb aquests objectes. Les relacions entre les entitats es gestionen mitjançant atributs i, en alguns casos, arrays d'objectes. La interacció amb la base de dades per persistir i recuperar aquests objectes sovint es fa a través de classes Repository o DAO.

Dissenyem¶

Pensar l’objectiu del projecte

Abans de picar codi, s’ ha de tenir clar:

Què farà la intranet? (per exemple: llistat de tasques, registre d’incidències, gestió de reserves...)

Qui la farà servir? (un sol usuari?, diversos?, administradors?)

Quines dades s’han de guardar i consultar? (quines taules a la base de dades caldran?)
Dibuixar el model de dades

S’ha de pensar quines taules necessita. Per exemple:

usuaris → per gestionar qui accedeix a la intranet

tasques → les dades que veurà cada usuari

Un exemple simple:
```
usuaris(id, nom, correu, contrasenya_hash)
tasques(id, descripcio, estat, usuari_id)
```
Crear la base de dades

A través de phpMyAdmin o directament amb comandes SQL, es crea les taules amb camps correctes, i es pot inseriri dades de prova.
Preparar la connexió amb PHP (connexio.php)

S’ha de crear un fitxer PHP reutilitzable que connecti amb la BDD utilitzant PDO.

Fer el sistema de login

Es pot fer:

Un formulari HTML amb camps per al correu i la contrasenya

Un fitxer PHP que:

Rep les dades

Consulta a la BDD si existeix l’usuari

Valida la contrasenya amb password_verify

Crea la sessió si és correcte

Exemple de codi que hauria d’escriure:

session_start();
if (password_verify($passwordFormulari, $contrasenyaBD)) {
    $_SESSION['usuari_id'] = $usuari['id'];
    $_SESSION['nom_usuari'] = $usuari['nom'];
    header('Location: intranet.php');
}

Controlar l’accés amb sessions

A cada pàgina privada (com intranet.php), s’ha d’afegir codi com aquest:
```
session_start();
if (!isset($_SESSION['usuari_id'])) {
    header('Location: login.php');
    exit;
}
```
Això assegura que només els usuaris identificats puguin veure les pàgines internes.

Mostrar dades des de la base de dades

Un cop autenticat, es pot mostrar dades associades al seu usuari:

$stmt = $pdo->prepare("SELECT * FROM tasques WHERE usuari_id = :id");
$stmt->execute(['id' => $_SESSION['usuari_id']]);
$tasques = $stmt->fetchAll();

Les pot mostrar amb HTML i un foreach.

Permetre afegir o modificar dades (CRUD)

Es poden crear formularis per afegir o modificar informació. Per exemple, un formulari per afegir una nova tasca:

El formulari envia dades amb POST

Un fitxer PHP rep les dades, comprova que hi ha sessió i les guarda a la BDD

Fer logout

Un fitxer senzill logout.php ha de contenir:

session_start();
session_destroy();
header('Location: login.php');

Frameworks de backend¶

Un framework de backend és una estructura fonamental preconstruïda que facilita i accelera el desenvolupament d'aplicacions web del costat del servidor (el backend). Pensa-ho com un conjunt d'eines, llibreries i regles arquitectòniques que et proporcionen una base sòlida per construir la teva aplicació sense haver de començar des de zero amb moltes tasques comunes.

Per què utilitzar un framework de backend?

Desenvolupament més ràpid: Els frameworks ofereixen moltes funcionalitats ja implementades, com ara el sistema de rutes (per gestionar les URLs), la interacció amb bases de dades (ORM - Object-Relational Mapping), la gestió de sessions, la validació de formularis, sistemes de plantilles per generar HTML dinàmicament, i molt més. Això et permet centrar-te en la lògica específica de la teva aplicació en lloc de reinventar la roda per a tasques bàsiques.
Organització i estructura del codi: Els frameworks solen imposar una estructura de projecte ben definida (com la que hem discutit abans, però de manera més estricta). Això fa que el codi sigui més organitzat, fàcil de mantenir, i comprensible per a altres desenvolupadors que puguin treballar en el projecte.
Seguretat: Molts frameworks tenen mecanismes de seguretat integrats per protegir contra vulnerabilitats comunes com la injecció SQL, els atacs CSRF (Cross-Site Request Forgery), i altres. Aquests mecanismes solen estar ben provats i actualitzats per la comunitat del framework.
- Reutilització de codi: Els frameworks promouen la reutilització de components i segueixen patrons de disseny provats, cosa que fa que el codi sigui més modular i mantenible a llarg termini.
- Comunitat i ecosistema: Els frameworks populars solen tenir una gran comunitat d'usuaris i desenvolupadors. Això significa que hi ha molta documentació, tutorials, fòrums de suport i paquets o llibreries addicionals (sovint anomenats "paquets" o "plugins") que poden ampliar la funcionalitat del framework.
- Escalabilitat: Molts frameworks estan dissenyats tenint en compte l'escalabilitat, proporcionant eines i patrons per construir aplicacions que puguin manejar un gran nombre d'usuaris i peticions.
- Consistència: Utilitzar un framework assegura una consistència en la manera de desenvolupar diferents parts de l'aplicació, cosa que facilita la col·laboració entre desenvolupadors.

Exemples de Frameworks de Backend en PHP:

Laravel: Un framework PHP molt popular conegut per la seva sintaxi elegant i les seves nombroses funcionalitats "out-of-the-box", com ara el sistema de rutes, l'ORM Eloquent, el sistema de plantilles Blade, i eines per a l'autenticació i l'autorització. És ideal per a projectes de mida mitjana a gran i té una gran comunitat.
Symfony: Un altre framework PHP molt potent i flexible, que serveix com a base per a molts altres projectes (incloent el gestor de continguts Drupal). És conegut per la seva arquitectura modular i la seva gran capacitat de configuració. És adequat per a projectes complexos i grans.
CodeIgniter: Un framework PHP més lleuger i senzill en comparació amb Laravel i Symfony. És fàcil d'aprendre i configurar, i és una bona opció per a projectes més petits o per a desenvolupadors que prefereixen tenir més control sobre els components que utilitzen.
CakePHP: Un altre framework PHP que segueix el patró de disseny Model-Vista-Controlador (MVC) i proporciona moltes eines per al desenvolupament ràpid d'aplicacions web.

Com un framework us ajudaria en el vostre projecte:

Si decidíssiu utilitzar un framework com Laravel, per exemple, per al vostre backend:

Gestió de rutes: Laravel us permetria definir fàcilment les URLs del vostre backend i associar-les a funcions específiques (els controladors) que gestionaran la lògica per a aquestes peticions.
Accés a la base de dades (Eloquent ORM): Laravel proporciona una manera elegant d'interactuar amb la vostra base de dades a través d'objectes PHP, sense haver d'escriure SQL directament per a moltes operacions.
Plantilles (Blade, TWIG, ...): El sistema de plantilles Blade facilitaria la generació dinàmica de HTML amb una sintaxi senzilla i potent.
Gestió de sessions i autenticació: Laravel té funcionalitats integrades per gestionar les sessions d'usuari i implementar sistemes d'autenticació de manera senzilla i segura.
Estructura organitzada: Laravel us forçaria a seguir una estructura de projecte MVC (Model-Vista-Controlador), cosa que ajudaria a mantenir el vostre codi ben organitzat.

resum

En resum, un framework de backend és com tenir un constructor experimentat amb un conjunt complet d'eines i un pla ben definit per construir la vostra casa (aplicació web). Us estalvia temps, us ajuda a evitar errors comuns, i us proporciona una base sòlida per construir aplicacions robustes i escalables.

Desenvolupament web dinàmic backend amb PHP Conceptes¶