---
# System prepended metadata

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

---

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

# 4. Curs SOC UF2. Model de programació web i base de dades
## La classe Tasca.

Començarem creant una carpeta que contingi tot el projecte:
```bash=
$ mkdir flask_todo_list
$ cd flask_todo_list
```
Un cop tenim creada la carpeta, generarem dues carpetes més a dins per separar la part del projecte que forma la part que enviarem al client de la part que correrà al servidor.
```bash=
flask_todo_list$ mkdir client
flask_todo_list$ mkdir server
```

La estructura de carpetes, normalment ve prefixada per la forma de fer de cada empresa, però en el nostre cas, per a desar el módul de la nostra classe tasca.py ho farem a ./server/src/app_todo/tasca.py, utilitzant les següents comandes:
```bash=
flask_todo_list$ mkdir -p ./server/src/app_todo
flask_todo_list$ touch ./server/src/app_todo/tasca.py
```
El primer pas es crear una classe buida que anomenarem Tasca dins del mòdul (fitxer) tasca.py
```python=
#!/usr/bin/python3

class Tasca():
    pass

```

Implementarem a dins totes les propietats que ens indica el diagrama de classes amb la excepcio de la propietat persistència, ja que encara no hem programat la classe adient.

```python=
#!/usr/bin/python3

class Tasca():

    """
    tasca.py conté la classe Tasca que és la classe principal de la nostra aplicació.
    """

    @property
    def id(self):
        return self._id

    @id.setter
    def id(self, valor):
        self._id = valor
    
    # @property
    # def persistencia(self):
    #     return self._persistencia

    @property
    def titol(self):
        return self._titol

    @titol.setter
    def titol(self, valor):
        self._titol = str(valor).strip()
    
    @property
    def done(self):
        return self._done       

    @done.setter
    def done(self, valor):
        self._done = valor

    def __init__(self, persistencia, titol, done=False, id=None):
        # assert issubclass(type(persistencia), src.app_todo.persistencia_tasca.Persistencia_tasca) 
        # self._persistencia = persistencia
        
        """
          la funció strip() treu els espais sobrants 
          del darrera i del començament d'una cadena de text.
        """
        self._titol = str(titol).strip()
        self._done = done
        self._id = id   

```
Ara ja tenim una classe Tasca força funcional, ens permet crear objectes del tipus Tasca i cada objecte tindrà una id, un títol i un estat done que ens indicarà si la tasca està feta o no.
Per a comprovar que la nostra 'tasca' es pot utilitzar, anem a crear un programa escrit en python que faci ús de la nostra nova classe:
* A la mateixa carpeta on tenim el mòdul tasca.py crearem un nou fitxer al que anomenarem prova_manual_tasca.py i escriurem a dins el següent codi: 
```python=
#!/usr/bin/python3

import tasca

def main():
    tasca_1 = tasca.Tasca(None, "Tasca nova 1")    # On None és persistencia i "Tasca nova 1" el nou títol.
    tasca_2 = tasca.Tasca(None, "Tasca nova 2")
    tasca_3 = tasca.Tasca(None, "Tasca nova 3")

    print(tasca_1)
    print(tasca_2)
    print(tasca_3)

if __name__ == "__main__":
    main()
```
* No oblideu crear un fitxer buit anomenat \_\_init\_\_.py, aquest fitxer indica a l'intèrpret de python que la carpeta conté mòduls de codi font susceptibles de ser importats.
* La sortida d'aquest script, hauria de ser semblant a:
```bash=
<tasca.Tasca object at 0x7f4232a18520>
<tasca.Tasca object at 0x7f4232a18790>
<tasca.Tasca object at 0x7f4232a1a1d0>
```
* Que com es pot apreciar no ens proporciona la informació més útil possible sobre les nostres tasques; sabem que la informació és allà però per recuperar-la necessitem demanar per ella, així que modificarem el codi per a que s'ens imprimeixi el titol de cada tasca i si està feta o no.
```python=
#!/usr/bin/python3

import tasca

def main():
    tasca_1 = tasca.Tasca(None, "Tasca nova 1")    # On None és persistencia i "Tasca nova 1" el nou títol.
    tasca_2 = tasca.Tasca(None, "Tasca nova 2")
    tasca_3 = tasca.Tasca(None, "Tasca nova 3")

    print(f"{tasca_1.titol}, {tasca_1.done}")
    print(f"{tasca_2.titol}, {tasca_2.done}")
    print(f"{tasca_3.titol}, {tasca_3.done}")

if __name__ == "__main__":
    main()
```
* Tot i que aquesta d'aquí dalt és una bona solució, també podem sobrescriure la funció __str__ de la nostra classe Tasca, de manera que sempre que demanem un print de Tasca ens mostri un json amb tota la informació necessària.
* La classe Tasca ara quedaria així:
```python=

#!/usr/bin/python3

import json

class Tasca():

    """
    tasca.py conté la classe Tasca que és la classe principal de la nostra aplicació.
    """

    @property
    def id(self):
        return self._id

    @id.setter
    def id(self, valor):
        self._id = valor
    
    # @property
    # def persistencia(self):
    #     return self._persistencia

    @property
    def titol(self):
        return self._titol

    @titol.setter
    def titol(self, valor):
        self._titol = str(valor).strip()
    
    @property
    def done(self):
        return self._done       

    @done.setter
    def done(self, valor):
        self._done = valor

    def __init__(self, persistencia, titol, done=False, id=None):
        # assert issubclass(type(persistencia), src.app_todo.persistencia_tasca.Persistencia_tasca) 
        # self._persistencia = persistencia
        
        """
          la funció strip() treu els espais sobrants 
          del darrera i del començament d'una cadena de text.
        """
        self._titol = str(titol).strip()
        self._done = done
        self._id = id   

    def __str__(self):
        resultat = {'id': self._id, 'titol': self._titol, 'done': self._done}
        return json.dumps(resultat)
```
En aquest moment tenim la nostra classe Tasca gairabé totalment funcional.