---
# System prepended metadata

title: 3. Curs SOC UF2.  Model de programació web i base de dades
tags: [SOC, ' UF2']

---

---
title: 3. Curs SOC UF2.  Model de programació web i base de dades
tags: SOC, UF2
---

# 3. Curs SOC UF2. Model de programació web i base de dades
## El __model__ o moll de l'os (core) de la nostra aplicació.
Si volem que la nostra aplicació sigui fàcil de provar i de mantenir, necessitem estructurar-la i sobre tot dotar-la de baix acoblament i alta cohesió.
Començarem per definir què és per a nosaltres una tasca i tota la relació de la nostra tasca amb la base de dades la farem a través d'una propietat que anomenarem 'persistència' que podrà ser de qualsevol tipus que implementi la _\<\<interface\>\>_ 'Persistencia_tasca', tot i que de moment només implementarem la classe 'Persistencia_tasca_sqlite'.
Aquesta forma de dissenyar la nostra aplicació, ens assegura que el dia que vulguem treballar amb un altre SGBD ja sigui relacional o no, no haurem de realitzar cap canvi a la nostra classe tasca i per tant no introduïrem cap error o malfuncionament al nucli (core) de la nostra aplicació només pel fet de canviar la base de dades. També podem estar segurs de que si provem exhaustivament el mètodes de la nova classe que implementen la interface, estarem força segurs de que la nova base de dades tampoc introduirà nous errors al nostre codi pre-existent.

## Diagrama UML de la nostra aplicació.
```mermaid
classDiagram
    class Tasca{
        + id: int
        + titol: str
        + done: boolean
        + persistencia: Persistencia_tasca
        
        + desa(): Tasca
        + delete()
    }
    class Persistencia_tasca{
        <<interface>>
        + desa(tasca: Tasca): int
        + delete(tasca: Tasca)
        + get_tasca(value: str, by: str)
        + get_list()
    }
    class Persistencia_tasca_sqlite{
        + ruta_db
    }
    Tasca --> Persistencia_tasca
    Persistencia_tasca_sqlite ..|> Persistencia_tasca
```
## Les classes Tasca i Persistencia_tasca_sqlite.
Hem d'implementar les classes Tasca i Persistencia_tasca_sqlite i la interface Persistencia_tasca amb les propietats i mètodes que mostra el diagrama de classes UML anterior. 
Com a guia se us subministra el següent constructor:
```python=
def __init__(self, persistencia, titol, done=False, id=None):
        assert issubclass(
            type(persistencia), 
            src.app_todo.persistencia_tasca.Persistencia_tasca
        ) 
        self._persistencia = persistencia
        self._titol = str(titol).strip()
        self._done = done
        self._id = id 
```
__Notes:__ 
* Persistència ha de ser una subclass de la interface (classe totalment abstracta i sense propietats) Persistència_tasca.
* Els paràmetres _done_ i _id_ són opcionals per què els hi estem donant un valor per defecte (tot i que el valor per defecte per a id sigui __None__ que indica que no té valor).
* El comportament previst, és que la persistència no es pugui canviar un cop inicialitzat un objecte, per aquesta raó no implementarem el setter de la propietat 'persistencia'.
* La funció desa de la classe Tasca ha de retornar-se a si mateixa amb la id actualitzada aconsseguida de la base de dades.
* La funció desa de la interface Persistència_tasca, ha de retornar la nova id que hagi generat el SGBD.
* Les funcions delete d'ambdues classes no han de retornar cap valor.
* La funció get_tasca ha de retornar un objecte del tipus Tasca.
* La funció get_list ha de retornar un array de Tasca amb totes les tasques de la base de dades.

També implementarem la nostra pròpia versió del mètode __str__ per a aconsseguir que la serialització en text de les instàncies de la nostra classe sigui JSONs que les representin.

```python=
def __str__(self):
        resultat = {'id': self._id, 'titol': self._titol, 'done': self._done}
        return json.dumps(resultat)
```
