Python y Flask
1.4
Implementación:
Modelos y
Controladores
Ciclo 4a
Programación Web
Universidad Nacional
de Colombia
Contenido
Implementación de los modelos ......................................................................................................... 2
Implementación de los controladores ............................................................................................... 6
Implementación métodos en la main ............................................................................................... 12
Descarga repositorio de código........................................................................................................ 13
Implementación de los modelos
La unidad básica de este tipo de sistemas son las clases las cuales ayudan a
modelar el código. Estas se almacenarán en una carpeta llamada “Modelos”, para
esto se debe dar click derecho sobre la carpeta del proyecto, “New”>”Directory” y
por último colocar el nombre de la carpeta, en este caso “Modelos” tal como se
muestra a continuación.
Luego, ubicados sobre esta nueva carpeta es necesario crear un nuevo archivo tipo
Python, el cual se definirá una clase abstracta llamada “AbstractModelo”, la cual
será el padre de todas las clases de tipo modelo que se implementarán mas
adelante. La creación de la clase abstracta se muestra a continuación:
Para este tutorial, la clase AbstractModelo tendrá un constructor especial el cual
permitirá instanciar un objeto del tipo requerido a partir de la información
almacenada en un diccionario, y esto será bastante útil para algunos procesos que
se llevarán mas adelante cuando se tengan que crear y manipular los objetos que
modelan la lógica del sistema. El código de esta clase se puede copiar a
continuación:
from abc import ABCMeta
class AbstractModelo(metaclass=ABCMeta):
def __init__(self,data):
for llave, valor in [Link]():
setattr(self, llave, valor)
Una vez se copie y pegue en la clase correspondiente, el código se debe quedar de
la siguiente manera:
Luego, se debe crear las clases para cada una de las entidades plasmadas en el
diagrama de diseño de la base de datos, en el presente tutorial, se realizará el
ejemplo con la entidad estudiante, pero el proceso es repetitivo para las demás tales
como inscripción, materia y departamento.
Para esto se procederá en crear un nuevo archivo sobre la carpeta “modelos”, y se
seleccionará “Python File”, luego es necesario colocar el nombre de la clase, para
este caso “Estudiante” como se muestra a continuación.
Luego dentro de este archivo es necesario escribir las siguientes líneas de código
from [Link] import AbstractModelo
class Estudiante(AbstractModelo):
pass
En la primera línea se está realizando la importación de la clase “AbstractModelo”,
en la línea 2 se está definiendo la clase “Estudiante” y dentro de paréntesis se coloca
el padre de esta clase “AbstractModelo”, es importante recordar que de esta clase
se heredará el constructor especializado (con esto se está ahorrando de copiar y
pegar el constructor en todas las clases), en este caso se está aplicando un
polimorfismo de sobre escritura. En el cuerpo de la clase se puede programar otros
métodos que son propios de esa clase, pero que se irán ampliando en los próximo
apartados, por lo pronto en la línea 3 se escribirá la palabra reservada “pass” la cual
es para hacer caso omiso y permitir que la clase tenga un primer cuerpo sin
presentar errores.
Dicho proceso se debe de repetir para las demás clases de “Departamento”,
“Materia” e “Inscripción”, finalmente se debería tener la estructura hasta este punto
de la siguiente manera:
Implementación de los controladores
A continuación se implementará el módulo de “Controladores”, estos serán los
encargados de manipular a los modelos, en estos se programarán las tareas
básicas tales como crear, listar, visualizar, modificar y eliminar. (CRUD)
Para esto es necesario crear una carpeta en el proyecto llamada “Controladores”
como se muestra en la siguiente imagen.
Luego, dentro de esta carpeta se creará el controlador para cada uno de los
modelos, a manera de ejemplo se implementará en este tutorial el controlador para
los estudiantes. Para esto es necesario crear un archivo de Python llamado
“ControladorEstudiante” como se muestra a continuación.
Dentro del archivo, se implementarán las funciones de CRUD anteriormente
mencionadas, bajo los nombres estándar para este proyecto como se describe a
continuación:
Index: Lista todos los elementos de una clase, por ejemplo trae la lista de
todos los estudiantes con sus atributos
Create: En este se llevará a cabo el proceso de creación de un objeto de la
clase específica, por ejemplo permitirá crear un objeto de tipo estudiante, y a
futuro almacenarlo en la base de datos
Show: Muestra la información específica de un objeto según su identificador,
por ejemplo permitirá visualizar la información de un estudiante según su id.
Update: Actualiza la información de un objeto según el identificador, por
ejemplo modificar la información de un estudiante.
Delete: Elimina la información de un objeto según su identificador, por
ejemplo borrar a un estudiante del sistema.
A continuación se muestra el código base que tendría cada uno de los
controladores, esto se debe replicar para crear los controladores de los
departamentos, materias e inscripciones.
from [Link] import Estudiante
class ControladorEstudiante():
def __init__(self):
print("Creando ControladorEstudiante")
def index(self):
print("Listar todos los estudiantes")
def create(self,elEstudiante):
print("Crear un estudiante")
def show(self,id):
print("Mostrando un estudiante con id ",id)
def update(self,id,elEstudiante):
print("Actualizando estudiante con id ",id)
def delete(self,id):
print("Elimiando estudiante con id ",id)
Se muestra a continuación un ejemplo de como debe ir quedando el controlador
estudiante hasta el momento.
Para este primer tutorial aún no se ha incluido la capa de persistencia de datos, pero
con el fin de tener una primera versión del servidor, se simulará el comportamiento
de respuesta que debe tener el controlador, programando el cuerpo de cada una de
las funciones.
from [Link] import Estudiante
class ControladorEstudiante():
def __init__(self):
print("Creando ControladorEstudiante")
def index(self):
print("Listar todos los estudiantes")
unEstudiante={
"_id":"abc123",
"cedula":"123",
"nombre":"Juan",
"apellido":"Perez"
}
return [unEstudiante]
def create(self,infoEstudiante):
print("Crear un estudiante")
elEstudiante = Estudiante(infoEstudiante)
return elEstudiante.__dict__
def show(self,id):
print("Mostrando un estudiante con id ",id)
elEstudiante = {
"_id": id,
"cedula": "123",
"nombre": "Juan",
"apellido": "Perez"
}
return elEstudiante
def update(self,id,infoEstudiante):
print("Actualizando estudiante con id ",id)
elEstudiante = Estudiante(infoEstudiante)
return elEstudiante.__dict__
def delete(self,id):
print("Elimiando estudiante con id ",id)
return {"deleted_count":1}
A continuación se explica algunas líneas importantes que componen la presente
clase. En la línea 3 se encuentra el constructor del controlador, el cual por defecto
es el método “__init__” este permite llevar a cabo crear instancias del controlador.
De la línea 5 a 13 está el método “index” en este se simula como la información de
cada estudiante estará dada en forma de diccionario, y al poder ser varios
estudiantes este debe ir dentro de una lista.
De la línea 14 a 17 se encuentra el método “create”, el cual recibirá un diccionario
con la información del estudiante, en la línea 16 se crea una objeto de tipo
estudiante, utilizando el constructor de la clase “AbstractModelo”, para garantizar
que el proceso se llevó a cabo correctamente el servidor retornará de nuevo la
información enviada, como se nota en la línea 17, se retorna el nombre del objeto
“elEstudiante” pero utilizando la conversión “__dict__” con el objetivo de convertir
un objeto a diccionario y poder enviarlo como respuesta mediante JSON, si esta
conversión no se realiza, el servidor tendrá problemas al momento de realizar la
respuesta ya que se envía serializado.
De la línea 18 a 26 se encuentra el método show, el cual simulará como al recibir
un parámetro de entrada de la petición como lo es el id, el sistema retornará un
diccionario con la información del estudiante.
De la línea 27 a 30 se encuentra la implementación del método update, y este
simulará como se modifica la información de un estudiante basado en el id y la
información nueva del estudiante.
Por último en las líneas 31 a 33 se encuentra la implementación del método delete,
el cual simulará como dado un id por parámetro se llevará a cabo el proceso de
eliminación, el servidor retornará un diccionario determinando la cantidad de
registros eliminados, en este caso al ser una simulación se retornará el valor de 1.
Para terminar con este ejemplo es momento de programar el archivo “main” para
que procese las peticiones realizadas desde el cliente. Para esto es necesario en la
main, importar e instanciar un objeto de tipo “ControladorEstudiante” esto con el fin
de poder manipular los modelos como ya se explicó anteriormente. Para esto se
deben de escribir las siguientes líneas en la main.
Implementación métodos en la main
from [Link] import ControladorEstudiante
miControladorEstudiante=ControladorEstudiante()
Luego de copiarlas, el código debe quedar de la siguiente manera, en la ubicación
que allí se muestra.
Luego se implementarán los métodos en la main en los cuales se definen las rutas
y tipos de peticiones a las cuales el servidor responderá, este código se puede
copiar a continuación
@[Link]("/estudiantes",methods=['GET'])
def getEstudiantes():
json=[Link]()
return jsonify(json)
@[Link]("/estudiantes",methods=['POST'])
def crearEstudiante():
data = request.get_json()
json=[Link](data)
return jsonify(json)
@[Link]("/estudiantes/<string:id>",methods=['GET'])
def getEstudiante(id):
json=[Link](id)
return jsonify(json)
@[Link]("/estudiantes/<string:id>",methods=['PUT'])
def modificarEstudiante(id):
data = request.get_json()
json=[Link](id,data)
return jsonify(json)
@[Link]("/estudiantes/<string:id>",methods=['DELETE'])
def eliminarEstudiante(id):
json=[Link](id)
return jsonify(json)
Como se evidencia está primero marcado mediante el decorador “@[Link]”
dentro del primer parámetro y en comillas, la ruta a la cual se puede realizar la
petición para que se active el método correspondiente, como también el tipo de
método.
Se puede detallar que existen 2 servicios con métodos “GET” como lo es traer todos
los estudiantes el cual tiene la ruta “url-servidor/estudiantes” (activa el método index
en el controlador), y el método traer un solo estudiante basado en su identificador
con la ruta “url-servidor /estudiantes/<string:id>” (activa el método show). Por otro
lado está un servicio con método “POST” y con ruta “url-servidor /estudiantes/” y
permite crear un nuevo estudiante. En ese método es importante enfatizar que
existe una variable “data” la cual toma la información del “body” específicamente en
la instrucción “ data = request.get_json()”, esto lo que hace es extraer la
información que viene desde el cliente en formato JSON y que servirá para continuar
en el proceso de creación del nuevo objeto. A continuación se encuentra un servicio
con método “PUT” y ruta “url-servidor /estudiantes/<string:id>” y permite modificar
un estudiante según el id e información que viene presente en la petición. Por último
está el método “DELETE” y url “url-servidor /estudiantes/<string:id>” y permite
eliminar un estudiante según su id.
Descarga repositorio de código
En el siguiente enlace puede encontrar el repositorio de código de lo trabajado en
el presente tutorial: [Link]
ciclo4/[Link]
