def crear_tag_usuario(self, p_nombre_tag, p_id_usuario, p_descripcion, p_lista_scrip):
"""
Añadimos un nuevo tag en el sistema
:param p_nombre_tag: El nombre del Tag
:param p_id_usuario: El identificador del usuario
:param p_descripcion: La descripción del Tag
:param p_lista_scrip: La lista de los scripts que se tiene que asociar
:return: True o False dependiendo si se ha insertado el tag corretamente
"""
# Primero se comprueba si el nombre del tag ya existe en el sistema.
bd = MySQLConnector.MySQLConnector()
exito = False
consulta1 = "SELECT IdTag FROM Tag WHERE NombreTag=%s AND IdUsuario=%s", (p_nombre_tag, p_id_usuario)
respuesta_bd_1 = bd.execute(consulta1)
if len(respuesta_bd_1) == 0:
# No existe el nombre en la BD, procedeemos a insertar el TAG
consulta2 = "INSERT INTO Tag(NombreTag,Descripcion,IdUsuario) VALUES(%s,%s,%s);", \
(p_nombre_tag, p_descripcion, p_id_usuario)
respuesta_bd_2 = bd.execute(consulta2)
if respuesta_bd_2 == 1:
# Se ha insertado el tag correctamente, añadimos los Scripts
# Obtenemos le identificador que se le ha asociado a nuestro nuevo TAG
consulta3 = "SELECT IdTag FROM Tag WHERE NombreTag=%s AND IdUsuario=%s", (p_nombre_tag, p_id_usuario)
respuesta_bd_3 = bd.execute(consulta3)
# Recorremos la lista de script y vamos insertado uno a uno en la BD
for script in p_lista_scrip:
consulta4 = "INSERT INTO Tag_Script(IdTag,IdScript) VALUES(%s,%s);", \
(int(respuesta_bd_3[0]['IdTag']), int(script['IdScript']))
bd.execute(consulta4)
exito = True
return exito
def anadir_grupo(self, p_nombre_grupo, p_id_usuario, p_lista_alumnos):
"""
Creamos un nuevo grupo en el sistema
:param p_nombre_grupo: El nombre del grupo
:param p_id_usuario: El identificador del usuario
:param p_lista_alumnos: La lista de alumnos que va a contener el nuevo grupo
:return: True --> Si todo ha ido como debería
False --> Si algo ha fallado
"""
devolver = False
bd = MySQLConnector.MySQLConnector()
consulta1 = "INSERT INTO Grupo(NombreGrupo,IdUsuario) VALUES(%s,%s);", (
p_nombre_grupo, p_id_usuario)
respuesta_bd = bd.execute(consulta1)
# Obtenemos el identificador del grupo
consulta2 = "SELECT IdGrupo FROM Grupo WHERE NombreGrupo=%s AND IdUsuario=%s;", (
p_nombre_grupo, p_id_usuario)
respuesta_bd_2 = bd.execute(consulta2)
id_grupo = int(respuesta_bd_2[0]['IdGrupo'])
respuesta_bd_3 = 0
# Insertamos la relación entre alumno y grupo
for alumno in p_lista_alumnos:
consulta3 = "INSERT INTO Alumno_Grupo(IdGrupo,Dni) VALUES(%s,%s);", \
(id_grupo, alumno['Dni'])
respuesta_bd_3 = bd.execute(consulta3)
if respuesta_bd_3 == 0:
# todo, deberiamos hacer una excepción en éste punto, indicando un fallo en la inserción.
break
if respuesta_bd == 1 and len(
respuesta_bd_2) != 0 and respuesta_bd_3 == 1:
# Los dos inserts han devuelvo 1 por lo que se han realizado correctamente y el SELECT devolvio datos
# Como han ido bien las cosas. Damos por éxito la operación.
devolver = True
return devolver
def eliminar_script(self, p_id_script, p_dni, p_id_usuario, p_id_grupo):
"""
Dado un script, llama a eliminar intencion.
:param p_id_script: El identificador del scriot
:param p_dni: El Dni del alumno
:param p_id_usuario: El identificador del usuario
:param p_id_grupo: El identificador del grupo
:return:
"""
exito = False
# Introducimos un control para evitar que el script sea borrado en caso de haber un Tag de por medio
bd = MySQLConnector.MySQLConnector()
consulta = """SELECT IdScript from Tag_Script WHERE IdScript=%s AND IdTag IN(SELECT IdTag FROM Tag_Grupo
WHERE IdGrupo=%s)""", (p_id_script, p_id_grupo)
respuesta_bd = bd.execute(consulta)
if len(respuesta_bd) != 0:
# El script ha sido adoptado por el Tag no hacemos nada
exito = True
else:
# Elimino la intención de la BD
actualizar_datos = self._eliminar_intencion(p_id_script, p_dni, p_id_usuario, p_id_grupo)
if actualizar_datos:
exito = True
else:
# Error garrafal, añadir alguna excepcion en éste punto
pass
return exito
def anadir_tag_al_grupo(self, p_id_grupo, p_id_tag):
"""
Añade la relación entre Tag_Grupo para dejar patente que a todos los alumnos se le han agregado el TAG
:param p_id_grupo:
:param p_id_tag:
:return:
"""
exito = False
exito_s = True
bd = MySQLConnector.MySQLConnector()
# Antes de añadir la intención, vamos a eliminar los posibles Script residuales.
# Obtenemos los tags del grupo actual
lista_script = self.obtener_scripts_tag(p_id_tag)
for script in lista_script:
consulta_s = "SELECT IdScript from Script_Grupo Where IdScript=%s AND IdGrupo=%s", (script['IdScript'],
p_id_grupo)
repuesta_s = bd.execute(consulta_s)
if len(repuesta_s) != 0:
# Este Script ya había sido aplicado. Vamos a eliminar la relación con el grupo
exito_s = self.eliminar_script_al_grupo(p_id_grupo, script['IdScript'])
if not exito_s:
break
if exito_s:
consulta = "INSERT INTO Tag_Grupo(IdGrupo,IdTag) VALUES (%s,%s);", (p_id_grupo, p_id_tag)
respuesta_bd = bd.execute(consulta)
if respuesta_bd == 1:
# Las inserciones han ido correctamente bien.
exito = True
return exito
def modificar_scripts_del_tag(self, p_id_tag, p_lista_cambios):
"""
Dada una lista de cambios. Se modifican los scripts que tenga un Tag.
:param p_id_tag:
:param p_lista_cambios:
:return: True -> Todos los cambios han sido correctos
False -> Algo no ha ido como deberia.
"""
exito = False
bd = MySQLConnector.MySQLConnector()
# Recorremos la lista
for cambio in p_lista_cambios:
if cambio['accion'] == 'borrar_script':
# Eliminamos la relación
consulta_1 = "DELETE FROM Tag_Script WHERE IdTag=%s AND IdScript=%s;", (p_id_tag, cambio['id_script'])
resultado_bd_1 = bd.execute(consulta_1)
if resultado_bd_1 == 1:
exito = True
else:
# Algo no ha ido bien
exito = False
break
else:
# Vamos a añadir un Script al TAg
consulta_2 = "INSERT INTO Tag_Script(IdTag,IdScript) VALUES (%s,%s);", (p_id_tag, cambio['id_script'])
resultado_bd_2 = bd.execute(consulta_2)
if resultado_bd_2 == 1:
exito = True
else:
exito = False
break
return exito
def obtener_info_tag(self, p_id_tag):
"""
Obtiene los datos relativos a un tag dado su identificador
:param p_id_tag: El identificador del Tag
:return: Los datos relativos al tag
"""
bd = MySQLConnector.MySQLConnector()
consulta = "SELECT NombreTag,Descripcion,FechaCreacion From Tag where IdTag=%s;", (p_id_tag, )
respuesta_bd_1 = bd.execute(consulta)
return respuesta_bd_1
def obtener_scripts_disponibles(self, p_id_grupo):
"""
Obtiene los scripts que no han sido aplicados en un grupo
:param p_id_grupo: EL identificador del grupo
:return: La lista de scripts NO aplicados en un grupo
"""
bd = MySQLConnector.MySQLConnector()
consulta = """SELECT IdScript,NombreScript,Descripcion FROM Script
WHERE IdScript NOT IN (SELECT IdScript FROM Script_Grupo WHERE IdGrupo=%s)
AND Activo=%s;""", (p_id_grupo, True)
respuesta_bd = bd.execute(consulta)
return respuesta_bd
def _execute_script(self, p_id_script, p_dni, p_accion):
"""
Aplicamos un script
:param p_id_script: El identificador del Script
:param p_dni: El Dni del alumno
:param p_accion: True -> Ejecuta el Script añadiendo datos
False -> Ejecuta el Script eliminando datos
:return: True o False dependiendo del éxito de la aplicación del script
"""
correcto = False
# Comprobar si la suma de verificación SHA-1 es correcta y en caso positivo continuar
bd = MySQLConnector.MySQLConnector()
consulta_1 = "SELECT Ruta,SHA FROM Script WHERE IdScript=%s;", (p_id_script,)
respuesta_bd = bd.execute(consulta_1)
if len(respuesta_bd) != 0:
consulta_2 = "SELECT Email FROM Alumno WHERE Dni=%s;", (p_dni,)
respuesta_bd_2 = bd.execute(consulta_2)
if len(respuesta_bd_2) != 0:
# Obtenemos el nombre de usuario del mail para usarlo como identificador en los servicios
ident_alumno = respuesta_bd_2[0]['Email'].split("@")[0]
# Obtenemos la Ruta del script
p = sub.Popen(("shasum", respuesta_bd[0]['Ruta']), stdout=sub.PIPE, stderr=sub.PIPE)
salidas_sha, errores_sha = p.communicate()
if len(salidas_sha) != 0:
# Comprobamos los SHA de la BD con el del archivo
salidas = salidas_sha.split()
if respuesta_bd[0]['SHA'] == salidas[0]:
# Los SHA coinciden, podemos ejecutar el script
p = sub.Popen(("/bin/bash", respuesta_bd[0]['Ruta'], ident_alumno, str(p_accion)),
stdout=sub.PIPE, stderr=sub.PIPE)
salidas, errores = p.communicate()
if len(salidas) != 0 and len(errores) == 0:
salidas = salidas.split('\n', 3)
if salidas[0] == "borrado":
# Se ha hecho una eliminación
correcto = self._enviar_mail(respuesta_bd_2[0]['Email'],
p_servicio=salidas[1], p_direccion=salidas[2])
else:
# El script se ha aplicado correctamente. Por lo tanto, enviaremos un mail con los cambios
# hacemos un slipt del usuario y contraseña que nos deevuelve el script
correcto = self._enviar_mail(respuesta_bd_2[0]['Email'], salidas[0], salidas[1],
salidas[2], salidas[3])
else:
# El script no se ha podido aplicar bien, raise exception
print errores
else:
# Error, los SHA NO son iguales. Raise exception
print "El SHA no coincide con el de la BD"
else:
# Error garrafal, raiseamos exception
print errores_sha
return correcto
def obtener_scripts_tag(self, p_id_tag):
"""
Obtiene los scripts que contiene un TAG
:param p_id_tag: Identificador del tag
:return: La lista de scripts que contiene un TAG
"""
bd = MySQLConnector.MySQLConnector()
consulta = """SELECT IdScript,NombreScript,Descripcion FROM Script
WHERE IdScript IN (SELECT IdScript FROM Tag_Script WHERE IdTag=%s)
AND Activo=%s;""", (p_id_tag, True)
respuesta_bd = bd.execute(consulta)
return respuesta_bd
def obtener_grupos(self, p_id_usuario):
"""
Obtenemos los grupos que tiene un usuario logueado
:param p_id_usuario: El identificador del uusairo
:return: La lista de los grupos que contiene el usuario
"""
bd = MySQLConnector.MySQLConnector()
consulta = "SELECT IdGrupo,NombreGrupo,IdUsuario FROM Grupo WHERE IdUsuario=%s order by FechaCreacion desc;", \
(p_id_usuario, )
respuesta_bd = bd.execute(consulta)
return respuesta_bd
def obtener_un_grupo(self, p_id_grupo):
"""
Dado el identificador de un grupo, obtenemos todos los datos relativos al mismo
:param p_id_grupo:
:return: Los datos relativos al grupo
"""
bd = MySQLConnector.MySQLConnector()
consulta = "SELECT IdGrupo,NombreGrupo,FechaCreacion,IdUsuario FROM Grupo WHERE IdGrupo=%s", (
p_id_grupo, )
respuesta_bd = bd.execute(consulta)
return respuesta_bd
def obtener_tags_usuario(self, p_id_usuario):
"""
Obtenemos los tags que ha creado un usuario en el sistema
:param p_id_usuario: El identificador del usuario
:return: Los tags que tiene el usuario
"""
bd = MySQLConnector.MySQLConnector()
consulta = "SELECT IdTag,NombreTag,Descripcion,FechaCreacion,IdUsuario FROM Tag WHERE IdUsuario=%s;", \
(p_id_usuario,)
respuesta_bd = bd.execute(consulta)
respuesta_bd_f_formateada = self._formatear_hora(respuesta_bd)
return respuesta_bd_f_formateada
def obtener_historial(self, p_id_usuario):
"""
Obtiene el historial dado el usuario
:param p_id_usuario: El identificador del usuario
:return: El historial completo de dicho usuario
"""
bd = MySQLConnector.MySQLConnector()
consulta = "SELECT * FROM Historial WHERE IdUsuario=%s ORDER BY Fecha desc;", (p_id_usuario, )
respuesta_bd = bd.execute(consulta)
return self._formatear_hora(respuesta_bd)
def obtener_tags(self, p_id_grupo):
"""
Obtenemos los tags que tiene aplicados un grupo.
:param p_id_grupo: El identificador del grupo
:return: Los datos relativos a cada tag que posee el grupo
"""
bd = MySQLConnector.MySQLConnector()
consulta = """SELECT IdTag,NombreTag,Descripcion,FechaCreacion,IdUsuario FROM Tag
WHERE IdTag IN (SELECT IdTag FROM Tag_Grupo WHERE IdGrupo=%s);
""", (p_id_grupo,)
respuesta_bd = bd.execute(consulta)
respuesta_bd_f_formateada = self._formatear_hora(respuesta_bd)
return respuesta_bd_f_formateada
def obtener_alumnos(self, p_id_grupo):
"""
Dado el idenficiador de un grupo, obtenemos los alumnos que lo contiene
:param p_id_grupo: Identificador del grupo
:return: La lista de los alumnos que compone el grupo
"""
bd = MySQLConnector.MySQLConnector()
consulta = """SELECT Dni,Nombre,Apellido,Email
FROM Alumno WHERE Dni IN (
SELECT Dni FROM Alumno_Grupo WHERE IdGrupo=%s);""", (p_id_grupo, )
respuesta_bd = bd.execute(consulta)
return respuesta_bd
def obtener_tags_disponibles(self, p_id_grupo, p_id_usuario):
"""
Obtenemos los tags que aún no han sido aplicados en un grupo
:param p_id_grupo: El identificador de un grupo
:return: Los tags que aún no han sido aplicados en un grupo
"""
bd = MySQLConnector.MySQLConnector()
consulta = """SELECT IdTag,NombreTag,Descripcion,FechaCreacion,IdUsuario FROM Tag
WHERE IdTag NOT IN (SELECT IdTag FROM Tag_Grupo WHERE IdGrupo=%s) AND IdUsuario=%s;
""", (p_id_grupo, p_id_usuario)
respuesta_bd = bd.execute(consulta)
respuesta_bd_f_formateada = self._formatear_hora(respuesta_bd)
return respuesta_bd_f_formateada
def obtener_grupos_tag(self, p_id_tag):
"""
Dado el identificador de un tag, obtenemos la información de los grupos en los que ha sido aplicado
:param p_id_tag: El identificador de un tag
:return: La lista de los grupos donde está aplicado dicho Tag.
"""
bd = MySQLConnector.MySQLConnector()
consulta = """SELECT IdGrupo,NombreGrupo,FechaCreacion,IdUsuario FROM Grupo WHERE IdGrupo IN (
SELECT IdGrupo FROM Tag_Grupo WHERE IdTag=%s);""" "", (
p_id_tag, )
respuesta_bd = bd.execute(consulta)
return respuesta_bd
def obtener_scripts_no_en_tag(self, p_id_tag):
"""
Obtiene los scritps que NO estan incluidos en un TAG
:param p_id_tag: El identificador de un tag
:return: La lista de los scripts que no están incluidos en un TAG
"""
bd = MySQLConnector.MySQLConnector()
consulta = """SELECT IdScript,NombreScript,Descripcion FROM Script
WHERE IdScript NOT IN (SELECT IdScript FROM Tag_Script WHERE IdTag=%s)
AND Activo=%s;""", (p_id_tag, True)
respuesta_bd = bd.execute(consulta)
return respuesta_bd
def obtener_todos_los_propietarios(self, p_id_usuario):
"""
Obtiene todos los propietarios disponibles para que puedan recibir un posible Tag por parte del usuario actual
del sistema
:param p_id_usuario: El identificador del usuario actual
:return: La lista de los usuarios que no poseen el Tag a heredar.
"""
bd = MySQLConnector.MySQLConnector()
consulta = "SELECT IdUsuario,Nombre,Apellido FROM Usuario WHERE NOT IdUsuario=%s", (
p_id_usuario, )
respuesta_bd = bd.execute(consulta)
return respuesta_bd
def borrar_grupo(self, p_id_grupo):
"""
Borra un grupo del sistema dado su identificador
:param p_id_grupo:
:return: Resultado de la BD
"""
resultado = False
bd = MySQLConnector.MySQLConnector()
consulta = "DELETE FROM Grupo WHERE IdGrupo=%s", (p_id_grupo, )
respuesta_bd = bd.execute(consulta)
if respuesta_bd == 1:
resultado = True
return resultado
def eliminar_scrit_al_tag(self, p_id_tag, p_id_script):
"""
Elimina la relación entre un Tag y un Script
:return: True o False dependiendo del éxito de la operación
"""
exito = False
bd = MySQLConnector.MySQLConnector()
consulta = "DELETE FROM Tag_Script WHERE IdTag=%s AND IdScript=%s;", (p_id_tag, p_id_script)
resultado_bd = bd.execute(consulta)
if resultado_bd == 1:
exito = True
return exito
def anadir_alumno(self, p_dni, p_nombre, p_apellido, p_email):
"""
Insertamos un nuevo alumno en la BD
:param p_dni:
:param p_nombre:
:param p_apellido:
:param p_email:
:return:
"""
bd = MySQLConnector.MySQLConnector()
consulta = """INSERT INTO Alumno(Dni,Nombre,Apellido,Email)
VALUES(%s,%s,%s,%s);""", (p_dni, p_nombre, p_apellido, p_email)
respuesta_bd = bd.execute(consulta)
return respuesta_bd
def borrar_tag(self, p_id_tag):
"""
Borra un Tag del sistema.
:param p_id_tag: El identificador del TAG
:return: True o False dependiendo del éxito de la operación
"""
resultado = False
bd = MySQLConnector.MySQLConnector()
consulta = "DELETE FROM Tag WHERE IdTag=%s;", (p_id_tag, )
respuesta_bd = bd.execute(consulta)
if respuesta_bd != 0:
resultado = True
return resultado
def buscar_alumno(self, p_dni):
"""
Busca la existencia de un alumno dado su dni
:param p_dni: El Dni del alumno
:return: -> None si no existen datos
-> Datos de un alumno si éste existe
"""
existe = None
bd = MySQLConnector.MySQLConnector()
consulta = "SELECT * FROM Alumno WHERE Dni=%s;", (p_dni, )
respuesta_bd = bd.execute(consulta)
if len(respuesta_bd) != 0:
# El alumno eexiste en la BD
existe = respuesta_bd
return existe
def anadir_script_al_tag(self, p_id_tag, p_id_script):
"""
Añade la relación entre un Tag y un Script
:param p_id_tag: El identificador del Tag
:param p_id_script: El identificador del Script
:return: True o False dependiendo del éxito de la operación
"""
exito = False
bd = MySQLConnector.MySQLConnector()
consulta = "INSERT INTO Tag_Script(IdTag,IdScript) VALUES (%s,%s);", (p_id_tag, p_id_script)
resultado_bd = bd.execute(consulta)
if resultado_bd == 1:
exito = True
return exito
def anadir_script_al_grupo(self, p_id_grupo, p_id_script):
"""
Añade la relación entre Grupo y Script. Cuando un script se ha aplicado a todos los alumnos de un grupo
:param p_id_gruo:
:param p_id_script:
:return:
"""
exito = False
bd = MySQLConnector.MySQLConnector()
consulta = "INSERT INTO Script_Grupo(IdGrupo,IdScript) VALUES (%s,%s);", (p_id_grupo, p_id_script)
respuesta_bd = bd.execute(consulta)
if respuesta_bd == 1:
exito = True
return exito
def obtener_credenciales(self, p_usuario, p_contrasena):
"""
Obtiene las credenciales de acceso de un usuario
:param p_usuario: El usuario
:param p_contrasena: Su contraseña
:return: Devuelve el IdUsuario en cuestión si los datos son correctos o None si no lo son.
"""
id_usuario = None
bd = MySQLConnector.MySQLConnector()
consulta = "SELECT IdUsuario FROM Usuario WHERE Usuario=%s AND Contrasena=%s;", (
p_usuario, p_contrasena)
# Comprobamos el valor de la consulta
respuesta_bd = bd.execute(consulta)
if len(respuesta_bd) != 0:
# El usuario y contraseña son correctos
id_usuario = int(respuesta_bd[0]['IdUsuario'])
return id_usuario
def cambiar_nombre(self, p_id_grupo, p_nombre_grupo):
"""
Cambiamos el nombre de un grupo si es posible
:param p_id_grupo: El identificador del grupo
:param p_nombre_grupo: EL nuevo nombre del grupo
:return: True o False dependiendo del cambio exitoso
"""
bd = MySQLConnector.MySQLConnector()
exito = False
consulta2 = "UPDATE Grupo SET NombreGrupo=%s WHERE IdGrupo=%s", (
p_nombre_grupo, p_id_grupo)
respuesta_bd_2 = bd.execute(consulta2)
# Comprobamos el éxito de la actualización
if respuesta_bd_2 == 1:
exito = True
return exito
def existe_script(self, p_id_grupo, p_id_script):
"""
Vericia si un script determinado está o no aplicado en un Grupo
:param p_id_script: El identificador del script
:param p_id_grupo: El identificador del grupo
:return: True -> El Script solicitado existe en el grupo
False -> El Script solicitado no existe en el grupo
"""
existe = False
bd = MySQLConnector.MySQLConnector()
consulta = "SELECT * FROM Script_Grupo WHERE IdScript=%s and IdGrupo=%s", (
p_id_script, p_id_grupo)
respuesta_bd = bd.execute(consulta)
if len(respuesta_bd) != 0:
existe = True
return existe
def eliminar_tag_al_grupo(self, p_id_grupo, p_id_tag):
"""
Elimina la relación entre Tag_Grupo para dejar patente que a todos los alumnos se le han eliminado el TAG
:param p_id_grupo:
:param p_id_tag:
:return:
"""
exito = False
bd = MySQLConnector.MySQLConnector()
consulta = "DELETE FROM Tag_Grupo WHERE IdGrupo=%s AND IdTag=%s;", (p_id_grupo, p_id_tag)
respuesta_bd = bd.execute(consulta)
if respuesta_bd == 1:
# Las inserciones han ido correctamente bien.
exito = True
return exito