def getAlumnos(sef, idAsociacion):
'''
Devuelve una lista con los alumnos matriculados en esa asignatura y grupo
Devuelve: id del alumno, nombre, apellidos e id
'''
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query="SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
isAsociacion='\''+idAsociacion+'\''
#Hacemos un JOIN de las tablas que relacionan alumnos con asociaciones y estas con profesores para luego sacar sólo las de cierto identificador e alumno.
#query='SELECT nombre, apellidos, id_alumno from Alumno where id_alumno IN (select id_alumno from Matricula where id_asociacion='+idAsociacion+');'
#Ver justificació de modificación en getProfesores:
query = 'SELECT nombre, apellidos, Alumno.id_alumno, id_matricula FROM (SELECT id_alumno, id_matricula FROM Matricula WHERE id_asociacion='+idAsociacion+') AS tablaMatricula, Alumno WHERE tablaMatricula.id_alumno = Alumno.id_alumno';
if v:
print query
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getAsociaciones(self):
'''
Devuelve una lista simplificada de todas las asociaciones dadas de alta en el sistema.
'''
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query="SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
query="select * from Asocia"
if v:
print '\n'+query
cursor.execute(query)
row = cursor.fetchone()
lista = []
while row is not None:
asociacion = Asociacion()
asociacion.id=row[0]
asociacion.id_clase=row[1]
asociacion.id_asignatura=row[2]
lista.append(asociacion)
#print row[0], row[1]
row = cursor.fetchone()
cursor.close()
db.close()
return lista
def nuevaAsociacion(self, id_clase, id_asignatura):
'''Introduce entidades en la tabla Asocia'''
db = dbParams.conecta()
#Añadimos al principio y al final una comilla simple a todos los elementos.
id_asignatura='\''+id_asignatura+'\''
id_clase='\''+id_clase+'\''
query="INSERT INTO Asocia VALUES(NULL, "+id_clase+","+id_asignatura+");"
if v:
print '\n'+query
cursor = db.cursor()
salida =''
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Asociacion con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getAsignaturas(self, idAlumno):
"""Devuelve una lista con las asignaturas en las que ese alumno está matriculado
"""
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query="SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
#Hacemos un JOIN de las tablas que relacionan alumnos con asociaciones y estas con profesores para luego sacar sólo las de cierto identificador e alumno.
query='select * from Asignatura where id in (select id_asignatura from Matricula where id_alumno='+idAlumno+')'
query='SELECT * FROM Asignatura WHERE id_asignatura IN (SELECT id_asignatura FROM Asocia WHERE id_asociacion IN (SELECT id_asociacion FROM Matricula WHERE id_alumno='+idAlumno+'));'
#select * from Matricula, Asignatura where Matricula.id_asignatura=Asignatura.id and id_alumno=4;
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getAsociacionCompleta(self, idAsociacion):
"""
Recupera TODA la información de un Asociacion en concreto a través de la clave primaria, su id.
"""
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query="SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
idAsociacion='\''+idAsociacion+'\''
#Montamos un alias para poder sacar el nombre de la asignatura sin ninguna subconsulta fea.
query='select * from (select * from Asocia where id_asociacion='+idAsociacion+') AS tablaAsocia, Asignatura where tablaAsocia.id_asignatura = Asignatura.id_asignatura;'
if v:
print '\n'+query
try:
salida = cursor.execute(query);
row = cursor.fetchone()
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
#Capturamos el error:
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def modClase(self, idClase, campoACambiar, nuevoValor):
"""
Esta función permite cambiar cualquier atributo de un Clase.
Parámetros:
campoACambiar: nombre del atributo que se quiere cambiar
nuevoValor: nuevo valor que se quiere guardar en ese campo.
"""
db = dbParams.conecta()
# La conexión está clara.
cursor = db.cursor()
idClase = "'" + idClase + "'"
# Al parámetro campoACambiar no se le añaden comillas para no generar un error de sintaxis en MySQL.
nuevoValor = "'" + nuevoValor + "'"
query = "UPDATE Clase SET " + campoACambiar + "=" + nuevoValor + " WHERE id_clase=" + idClase + ";"
if v:
print "\n" + query
cursor = db.cursor()
salida = ""
# Manejo de excepciones.
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getClases(self, idProfesor):
"""
Devuelve una lista con las clases en los que ese profesor da clase, normalmente será al menos uno.
"""
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query="SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
#Hacemos un JOIN de las tablas que relacionan alumnos con asociaciones y estas con profesores para luego sacar sólo las de cierto identificador e alumno.
query='SELECT * FROM Clase WHERE id_clase IN (SELECT id_clase FROM Asocia where id_asociacion IN(SELECT id_asociacion FROM Imparte WHERE id_profesor='+idProfesor+'));'
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def modClaseCompleta(self, idClase, curso, grupo, nivel):
"""
Modifica todos los atributos de una clase dado su id al mismo tiempo.
"""
# Info de seguimiento
if v:
print apiName
print "Llamada a modClaseCompleta"
print "\n"
db = dbParams.conecta()
query = "UPDATE Clase SET"
query = query + " curso= " + "'" + curso + "'"
query = query + " , grupo= " + "'" + grupo + "'"
query = query + " , nivel= " + "'" + nivel + "'"
query = query + " WHERE id_clase=" + idClase + ";"
if v:
print apiName
print query
cursor = db.cursor()
salida = ""
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getAlumnos(self, idProfesor):
"""
Devuelve una lista con los alumnos al que imparte clase ese profesor, incluyendo
los campos id, nombre, apellidos y dni de los alumnos del profesor
Argumentos:
dniProfesor: El dni del profsor del que se pide la información.<
"""
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query="SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
#Hacemos un JOIN de las tablas que relacionan alumnos con asociaciones y estas con profesores para luego sacar sólo las de cierto identificador e alumno.
query='SELECT nombre, apellidos, id_alumno FROM Alumno WHERE id_alumno IN (SELECT id_alumno FROM Imparte, Matricula WHERE Imparte.id_asociacion=Matricula.id_asociacion AND Imparte.id_profesor='+idProfesor+');'
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def modClase(self, idClase, campoACambiar, nuevoValor):
'''
Esta función permite cambiar cualquier atributo de un Clase.
Parámetros:
campoACambiar: nombre del atributo que se quiere cambiar
nuevoValor: nuevo valor que se quiere guardar en ese campo.
'''
db = dbParams.conecta()
#La conexión está clara.
cursor = db.cursor()
idClase = '\'' + idClase + '\''
#Al parámetro campoACambiar no se le añaden comillas para no generar un error de sintaxis en MySQL.
nuevoValor = '\'' + nuevoValor + '\''
query = "UPDATE Clase SET " + campoACambiar + "=" + nuevoValor + " WHERE id_clase=" + idClase + ";"
if v:
print '\n' + query
cursor = db.cursor()
salida = ''
#Manejo de excepciones.
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def nuevaAsociacion(self, id_clase, id_asignatura):
'''Introduce entidades en la tabla Asocia'''
db = dbParams.conecta()
#Añadimos al principio y al final una comilla simple a todos los elementos.
id_asignatura = '\'' + id_asignatura + '\''
id_clase = '\'' + id_clase + '\''
query = "INSERT INTO Asocia VALUES(NULL, " + id_clase + "," + id_asignatura + ");"
if v:
print '\n' + query
cursor = db.cursor()
salida = ''
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Asociacion con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getAlumnos(sef, idAsociacion):
'''
Devuelve una lista con los alumnos matriculados en esa asignatura y grupo
Devuelve: id del alumno, nombre, apellidos e id
'''
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query = "SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
isAsociacion = '\'' + idAsociacion + '\''
#Hacemos un JOIN de las tablas que relacionan alumnos con asociaciones y estas con profesores para luego sacar sólo las de cierto identificador e alumno.
#query='SELECT nombre, apellidos, id_alumno from Alumno where id_alumno IN (select id_alumno from Matricula where id_asociacion='+idAsociacion+');'
#Ver justificació de modificación en getProfesores:
query = 'SELECT nombre, apellidos, Alumno.id_alumno, id_matricula FROM (SELECT id_alumno, id_matricula FROM Matricula WHERE id_asociacion=' + idAsociacion + ') AS tablaMatricula, Alumno WHERE tablaMatricula.id_alumno = Alumno.id_alumno'
if v:
print query
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getAlumno(self, idAlumno):
"""
Recupera ``TODA`` la información de un alumno en concreto a través de su id.
Argumentos:
idAlumno: identificador unívoco del alumno en la tabla
"""
db = dbParams.conecta(); #La conexión está clara.
cursor = db.cursor()
idAlumno='\''+idAlumno+'\''
query='select * from Alumno where id_alumno='+idAlumno+';'
if v:
print 'Query in GestorAlumnosSQL.getAlumno()'
print query
try:
salida = cursor.execute(query);
row = cursor.fetchone()
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getAsignaturas(self):
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query="SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
query="select * from Asignatura"
if v:
print '\n'+query
cursor.execute(query)
row = cursor.fetchone()
lista = []
while row is not None:
asignatura = Asignatura()
#print "LISTA SUPER CHACHI"
asignatura.id=row[0]
asignatura.nombre=row[1]
lista.append(asignatura)
#print row[0], row[1]
row = cursor.fetchone()
cursor.close()
db.close()
return lista
def modAlumno(self, idAlumno, campoACambiar, nuevoValor):
"""
Esta función permite cambiar cualquier atributo de un alumno, dado su id.
Parámetros:
campoACambiar: nombre del atributo que se quiere cambiar
nuevoValor: nuevo valor que se quiere guardar en ese campo.
"""
db = dbParams.conecta(); #La conexión está clara.
nuevoValor='\''+nuevoValor+'\''
idAlumno='\''+idAlumno+'\''
query="UPDATE Alumno SET "+campoACambiar+"="+nuevoValor+" WHERE id_alumno="+idAlumno+";"
cursor = db.cursor()
salida =''
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el alumno con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def modAsociacion(self, id_clase, id_asignatura, campoACambiar,
nuevoValor):
"""
Esta función permite cambiar cualquier atributo de una Asociacion.
Parámetros:
campoACambiar: nombre del atributo que se quiere cambiar
nuevoValor: nuevo valor que se quiere guardar en ese campo.
Este caso puede ser delicado al tener sólo dos atributos y ambos ser claves foráneas. Por eso no permitiremos que
se haga, para modificar la relación antes tendremos que destruirla y volverla a crear.
"""
db = dbParams.conecta()
nuevoValor = '\'' + nuevoValor + '\''
id_asignatura = '\'' + id_asignatura + '\''
id_clase = '\'' + id_clase + '\''
query = "UPDATE Asocia SET " + campoACambiar + "=" + nuevoValor + " WHERE id_asignatura=" + id_asignatura + " and id_clase=" + id_clase + ";"
if v:
print '\n' + query
cursor = db.cursor()
salida = ''
'''
#Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Asociacion con clave
#que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getMatriculas(self):
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query = "SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
query = "select * from Matricula"
if v:
print '\n' + query
cursor.execute(query)
row = cursor.fetchone()
lista = []
while row is not None:
matricula = Matricula()
matricula.id = row[0]
matricula.id_alumno = row[1]
matricula.id_asociacion = row[2]
lista.append(matricula)
#print row[0], row[1]
row = cursor.fetchone()
cursor.close()
db.close()
return lista
def modAsignaturaCompleta(self, idAsignatura, nombre):
'''
Modifica todos los atributos de una asignatura dado su id al mismo tiempo.
'''
#Info de seguimiento
if v:
print apiName
print "Llamada a modAsignaturaCompleta"
print '\n'
db = dbParams.conecta();
query="UPDATE Asignatura SET"
query=query+" nombre= "+'\''+nombre+'\''
query=query+" WHERE id_asignatura="+idAsignatura+";"
if v:
print apiName
print query.encode('utf-8')
cursor = db.cursor()
salida =''
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def nuevoImparte(self, id_asociacion, id_profesor):
'''Introduce una tupla en la tabla Imparte de la base de datos'''
db = dbParams.conecta()
#query="INSERT INTO Imparte values("+"'"+nombre+"', "+ "'"+id+"');"
#Añadimos al principio y al final una comilla simple a todos los elementos.
id_asociacion = '\'' + id_asociacion + '\''
id_profesor = '\'' + id_profesor + '\''
query = "INSERT INTO Imparte VALUES(NULL, " + id_asociacion + "," + id_profesor + ");"
if v:
print '\n' + query
cursor = db.cursor()
salida = ''
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Imparte con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = str(e.args[0])
except IndexError:
print "MySQL Error: %s" % str(e)
def getImpartes(self):
'''Devuelve una lista simlifacada de todos los elementos Imparte de la tabla imparte de la bd'''
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query = "SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
query = "select * from Imparte"
if v:
print '\n' + query
cursor.execute(query)
row = cursor.fetchone()
lista = []
while row is not None:
imparte = Imparte()
imparte.id_clase = row[0]
imparte.id_asignatura = row[1]
imparte.id_profesor = row[2]
lista.append(imparte)
#print row[0], row[1]
row = cursor.fetchone()
cursor.close()
db.close()
return lista
def getAsociaciones(self):
'''
Devuelve una lista simplificada de todas las asociaciones dadas de alta en el sistema.
'''
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query = "SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
query = "select * from Asocia"
if v:
print '\n' + query
cursor.execute(query)
row = cursor.fetchone()
lista = []
while row is not None:
asociacion = Asociacion()
asociacion.id = row[0]
asociacion.id_clase = row[1]
asociacion.id_asignatura = row[2]
lista.append(asociacion)
#print row[0], row[1]
row = cursor.fetchone()
cursor.close()
db.close()
return lista
def getProfesores(self, idAlumno):
"""
Devuelve una lista de los profesores que imparte clase a ese alumno.
Argumentos:
idAlumno: El id del alumno del que se pide la información.
"""
db = dbParams.conecta()
cursor = db.cursor()
idAlumno='\''+idAlumno+'\''
#Sacando los acentos...........
mysql_query="SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
#Hacemos un JOIN de las tablas que relacionan alumnos con asociaciones y estas con profesores para luego sacar sólo las de cierto identificador e alumno.
#query='SELECT id_profesor, nombre, apellidos from Profesor where id_profesor in ( select id_profesor from Imparte where id_asignatura in (select id_asignatura from Matricula where id_alumno='+idAlumno+') and id_clase in (select id_clase from Matricula where id_alumno='+idAlumno+'))'
query='SELECT nombre, apellidos, id_profesor FROM Profesor WHERE id_profesor IN (SELECT id_profesor FROM Imparte, Matricula WHERE Imparte.id_asociacion=Matricula.id_asociacion and Matricula.id_alumno='+idAlumno+');'
if v:
print query
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getMatriculas(self):
db = dbParams.conecta();
cursor = db.cursor()
#Sacando los acentos...........
mysql_query="SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
query="select * from Matricula"
if v:
print '\n'+query
cursor.execute(query)
row = cursor.fetchone()
lista = []
while row is not None:
matricula = Matricula()
matricula.id=row[0]
matricula.id_alumno=row[1]
matricula.id_asociacion=row[2]
lista.append(matricula)
#print row[0], row[1]
row = cursor.fetchone()
cursor.close()
db.close()
return lista
def nuevaMatricula(self, id_alumno, id_asociacion):
'''
Da de alta una matrícula en el sistema.
'''
db = dbParams.conecta();
#query="INSERT INTO Matricula values("+"'"+nombre+"', "+ "'"+id+"');"
#Añadimos al principio y al final una comilla simple a todos los elementos.
id_asociacion='\''+id_asociacion+'\''
id_alumno='\''+id_alumno+'\''
query="INSERT INTO Matricula VALUES (NULL, "+id_alumno+","+id_asociacion+");"
if v:
print '\n'+query
cursor = db.cursor()
salida =''
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Matricula con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getImpartes(self):
'''Devuelve una lista simlifacada de todos los elementos Imparte de la tabla imparte de la bd'''
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query="SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
query="select * from Imparte"
if v:
print '\n'+query
cursor.execute(query)
row = cursor.fetchone()
lista = []
while row is not None:
imparte = Imparte()
imparte.id_clase=row[0]
imparte.id_asignatura=row[1]
imparte.id_profesor=row[2]
lista.append(imparte)
#print row[0], row[1]
row = cursor.fetchone()
cursor.close()
db.close()
return lista
def getAsociacionCompleta(self, idAsociacion):
"""
Recupera TODA la información de un Asociacion en concreto a través de la clave primaria, su id.
"""
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query = "SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
idAsociacion = '\'' + idAsociacion + '\''
#Montamos un alias para poder sacar el nombre de la asignatura sin ninguna subconsulta fea.
query = 'select * from (select * from Asocia where id_asociacion=' + idAsociacion + ') AS tablaAsocia, Asignatura where tablaAsocia.id_asignatura = Asignatura.id_asignatura;'
if v:
print '\n' + query
try:
salida = cursor.execute(query)
row = cursor.fetchone()
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
#Capturamos el error:
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def modAsignatura(self, idAsignatura, campoACambiar, nuevoValor):
"""
Esta función permite cambiar cualquier atributo de un Asignatura.
Parámetros:
campoACambiar: nombre del atributo que se quiere cambiar
nuevoValor: nuevo valor que se quiere guardar en ese campo.
"""
db = dbParams.conecta(); #La conexión está clara.
nuevoValor='\''+nuevoValor+'\''
idAsignatura='\''+idAsignatura+'\''
query="UPDATE Asignatura SET "+campoACambiar+"="+nuevoValor+" WHERE id_asignatura="+idAsignatura+";"
if v:
print '\n'+query
cursor = db.cursor()
salida =''
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Asignatura con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def modAsociacion(self, id_clase, id_asignatura, campoACambiar, nuevoValor):
"""
Esta función permite cambiar cualquier atributo de una Asociacion.
Parámetros:
campoACambiar: nombre del atributo que se quiere cambiar
nuevoValor: nuevo valor que se quiere guardar en ese campo.
Este caso puede ser delicado al tener sólo dos atributos y ambos ser claves foráneas. Por eso no permitiremos que
se haga, para modificar la relación antes tendremos que destruirla y volverla a crear.
"""
db = dbParams.conecta()
nuevoValor='\''+nuevoValor+'\''
id_asignatura='\''+id_asignatura+'\''
id_clase='\''+id_clase+'\''
query="UPDATE Asocia SET "+campoACambiar+"="+nuevoValor+" WHERE id_asignatura="+id_asignatura+" and id_clase="+id_clase+";"
if v:
print '\n'+query
cursor = db.cursor()
salida =''
'''
#Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Asociacion con clave
#que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def nuevoImparte(self, id_asociacion, id_profesor):
'''Introduce una tupla en la tabla Imparte de la base de datos'''
db = dbParams.conecta();
#query="INSERT INTO Imparte values("+"'"+nombre+"', "+ "'"+id+"');"
#Añadimos al principio y al final una comilla simple a todos los elementos.
id_asociacion='\''+id_asociacion+'\''
id_profesor='\''+id_profesor+'\''
query="INSERT INTO Imparte VALUES(NULL, "+id_asociacion+","+id_profesor+");"
if v:
print '\n'+query
cursor = db.cursor()
salida =''
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Imparte con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=str(e.args[0])
except IndexError:
print "MySQL Error: %s" % str(e)
def getAsociaciones(self, idClase):
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query = "SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
idClase = '\'' + idClase + '\''
#query='SELECT * FROM Asocia WHERE id_clase='+idClase+';'
query = 'select * from (select * from Asocia where id_clase=' + idClase + ') AS tablaAsocia, Asignatura where tablaAsocia.id_asignatura = Asignatura.id_asignatura;'
if v:
print '\n' + query
cursor.execute(query)
row = cursor.fetchone()
lista = []
while row is not None:
asociacion = Asociacion()
asociacion.id = row[0]
asociacion.idClase = row[1]
asociacion.idAsignatura = row[2]
asociacion.nombreAsignatura = row[4]
lista.append(asociacion)
row = cursor.fetchone()
cursor.close()
db.close()
return lista
def modClaseCompleta(self, idClase, curso, grupo, nivel):
'''
Modifica todos los atributos de una clase dado su id al mismo tiempo.
'''
#Info de seguimiento
if v:
print apiName
print "Llamada a modClaseCompleta"
print '\n'
db = dbParams.conecta()
query = "UPDATE Clase SET"
query = query + " curso= " + '\'' + curso + '\''
query = query + " , grupo= " + '\'' + grupo + '\''
query = query + " , nivel= " + '\'' + nivel + '\''
query = query + " WHERE id_clase=" + idClase + ";"
if v:
print apiName
print query
cursor = db.cursor()
salida = ''
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def nuevaMatricula(self, id_alumno, id_asociacion):
'''
Da de alta una matrícula en el sistema.
'''
db = dbParams.conecta()
#query="INSERT INTO Matricula values("+"'"+nombre+"', "+ "'"+id+"');"
#Añadimos al principio y al final una comilla simple a todos los elementos.
id_asociacion = '\'' + id_asociacion + '\''
id_alumno = '\'' + id_alumno + '\''
query = "INSERT INTO Matricula VALUES (NULL, " + id_alumno + "," + id_asociacion + ");"
if v:
print '\n' + query
cursor = db.cursor()
salida = ''
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Matricula con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getProfesores(self, idClase):
'''
Devuelve la lista de profesores que están impartien a esa clase.
Devuelve dni, nombre y apellidos
'''
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query = "SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
idClase = '\'' + idClase + '\''
#
query = 'SELECT id_profesor, nombre, apellidos from Profesor where id_profesor IN (select id_profesor from Imparte where id_asociacion IN (select id_asociacion from Asocia where id_clase=' + idClase + '))'
if v:
print '\n' + query
cursor.execute(query)
row = cursor.fetchone()
lista = []
while row is not None:
profesor = Profesor()
profesor.id = row[0]
profesor.nombre = row[1]
profesor.apellidos = row[2]
lista.append(profesor)
#print row[0], row[1]
row = cursor.fetchone()
cursor.close()
db.close()
return lista
def modAlumnoCompleto(self, idAlumno, nombre, apellidos='NULL', dni='NULL', direccion='NULL', localidad='NULL', provincia='NULL', fecha_nacimiento='NULL', telefono='NULL', imagen='NULL'):
'''
Modifica todos los atributos de un alumno dado su id al mismo tiempo.
'''
#Info de seguimiento
if v:
print apiName
print "Llamada a modAlumnoCompleto"
print '\n'
print locals()
db = dbParams.conecta();
query="UPDATE Alumno SET"
query=query+" nombre= "+'\''+nombre+'\''
query=query+" , apellidos= "+'\''+apellidos+'\''
if dni=='NULL':
query=query+" , dni=NULL "
else:
query=query+" , dni= "+'\''+dni+'\''
query=query+" , direccion= "+'\''+direccion+'\''
query=query+" , localidad= "+'\''+localidad+'\''
query=query+" , provincia= "+'\''+provincia+'\''
if fecha_nacimiento=='NULL':
query=query+" , fecha_nacimiento=NULL "
else:
query=query+" , fecha_nacimiento= "+'\''+fecha_nacimiento+'\''
query=query+" , telefono= "+'\''+telefono+'\''
query=query+" , url_imagen= "+'\''+imagen+'\''
#Codificamos el id porque es el único que no viene codificado desde la api para que no de problema al concatenar con la sentencia SQL
query=query+" WHERE id_alumno="+dbParams.formatOutputText(idAlumno)+";"
if v:
print apiName
print '\n'+query
cursor = db.cursor()
#Sacando los acentos...........
mysql_query="SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
salida =''
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def comprobarUsuario(self, username, password):
'''
Comprueba si el usuario tiene permisos de acceso al sistema.
'''
if v:
print apiName
print ' Calling '+ str(locals()['self'])
print ' '+str(locals())
#Usamos el gestor para la conexión
db = dbParams.conecta()
#Añadimos al principio y al final una comilla simple a todos los elementos.
username='******''+username+'\''
password='******''+password+'\''
query='SELECT * FROM Credenciales WHERE username='******' and password= AES_ENCRYPT('+password+',"CLAVESECRETA");'
if v:
print ' '+query
cursor = db.cursor()
salida =''
cred = Credenciales()
encontrado = True
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Asignatura con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
#Cuando el usuario no es encontrado devuelve 0
salida = cursor.execute(query)
row = cursor.fetchone()
if row != None:
cred.idUsuario=row[1]
cred.nombre=row[2]
cred.rol=row[5]
except dbParams.MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def nuevoProfesor(self, nombre, apellidos='NULL', dni='NULL', direccion='NULL', localidad='NULL', provincia='NULL', fecha_nacimiento='NULL', telefono='NULL'):
'''
Introduce un nuevo elemento Profesor en la base de datos.
Necesita como mínimo un nombre y un dni
'''
if v:
print apiName
print ' Calling '+ str(locals()['self'])
print ' '+str(locals())
db = dbParams.conecta(); #La conexión está clara.
nombre='\''+nombre+'\''
if(apellidos!='NULL'):
apellidos='\''+apellidos+'\''
#DNI se pasa como un entero y no es necesario comillarlo.
if(direccion!='NULL'):
direccion='\''+direccion+'\''
if(localidad!='NULL'):
localidad='\''+localidad+'\''
if(provincia!='NULL'):
provincia='\''+provincia+'\''
if(fecha_nacimiento!='NULL'):
fecha_nacimiento='\''+fecha_nacimiento+'\''
if(telefono!='NULL'):
telefono='\''+telefono+'\''
query="INSERT INTO Profesor VALUES(NULL,"+nombre+","+apellidos+","+dni+","+direccion+","+localidad+","+provincia+","+fecha_nacimiento+","+telefono+");"
if v:
print ' '+query+'\n'
cursor = db.cursor()
salida =''
idProfesor=''
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Profesor con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
salida = cursor.execute(query)
idProfesor = cursor.lastrowid
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def comprobarUsuario(self, username, password):
'''
Comprueba si el usuario tiene permisos de acceso al sistema.
'''
if v:
print apiName
print ' Calling ' + str(locals()['self'])
print ' ' + str(locals())
#Usamos el gestor para la conexión
db = dbParams.conecta()
#Añadimos al principio y al final una comilla simple a todos los elementos.
username = '******'' + username + '\''
password = '******'' + password + '\''
query = 'SELECT * FROM Credenciales WHERE username='******' and password= AES_ENCRYPT(' + password + ',"CLAVESECRETA");'
if v:
print ' ' + query
cursor = db.cursor()
salida = ''
cred = Credenciales()
encontrado = True
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Asignatura con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
#Cuando el usuario no es encontrado devuelve 0
salida = cursor.execute(query)
row = cursor.fetchone()
if row != None:
cred.idUsuario = row[1]
cred.nombre = row[2]
cred.rol = row[5]
except dbParams.MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def modProfesorCompleto(self, idProfesor, nombre, apellidos='NULL', dni='NULL', direccion='NULL', localidad='NULL', provincia='NULL', fecha_nacimiento='NULL', telefono='NULL'):
'''
Modifica todos los atributos de un profesor dado su id al mismo tiempo.
'''
#Info de seguimiento
if v:
print apiName
print "Llamada a modProfesorCompleto"
print '\n'
db = dbParams.conecta();
query="UPDATE Profesor SET"
query=query+" nombre= "+'\''+nombre+'\''
query=query+" , apellidos= "+'\''+apellidos+'\''
if dni=='NULL':
query=query+" , dni=NULL "
else:
query=query+" , dni= "+'\''+dni+'\''
query=query+" , direccion= "+'\''+direccion+'\''
query=query+" , localidad= "+'\''+localidad+'\''
query=query+" , provincia= "+'\''+provincia+'\''
if fecha_nacimiento=='NULL':
query=query+" , fecha_nacimiento=NULL "
else:
query=query+" , fecha_nacimiento= "+'\''+fecha_nacimiento+'\''
query=query+" , telefono= "+'\''+telefono+'\''
query=query+" WHERE id_profesor="+idProfesor+";"
if v:
print apiName
print query
cursor = db.cursor()
salida =''
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def delMatricula(self, id_matricula):
db = dbParams.conecta();
cursor = db.cursor()
id_matricula='\''+id_matricula+'\''
query="delete from Matricula where id_matricula="+id_matricula+";"
if v:
print query
salida =''
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def delAsignatura(self, idAsignatura):
if v:
print "Intentado eliminar asignatura con id "+str(idAsignatura)
db = dbParams.conecta(); #La conexión está clara.
cursor = db.cursor()
query="delete from Asignatura where id_asignatura='"+idAsignatura+"';"
salida =''
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getNumAlumnos(self):
'''Devuelve el número de alumnos de la BD'''
db = dbParams.conecta(); #La conexión está clara.
cursor = db.cursor()
query="select count(*) from Alumno;"
salida =''
try:
salida = cursor.execute(query);
row = cursor.fetchone()
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getNumAsignaturas(self):
'''Devuelve el número de asignaturas de la BD'''
db = dbParams.conecta(); #La conexión está clara.
cursor = db.cursor()
query="select count(*) from Asignatura;"
salida =''
try:
salida = cursor.execute(query);
row = cursor.fetchone()
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getAsignaturas(self, idClase):
"""
Devuelve una lista con las asignaturas que se dan a esa clase.
Ejemplo:
En 2ºESO se da Frances, Lengua, etc...
Parámetros:
curso, grupo y nivel: identificadores que forman el unívoco de una clase.
Devuelve: Una lista de objetos de tipo asignatura
"""
db = dbParams.conecta()
cursor = db.cursor()
# Sacando los acentos...........
mysql_query = "SET NAMES 'utf8'"
cursor.execute(mysql_query)
# -----------------------------#
idClase = "'" + idClase + "'"
query = (
"select * from Asignatura where id_asignatura in (select id_asignatura from Asocia where id_clase ="
+ idClase
+ ")"
)
if v:
print "\n" + query
cursor.execute(query)
row = cursor.fetchone()
lista = []
while row is not None:
asignatura = Asignatura()
asignatura.id = row[0]
asignatura.nombre = row[1]
lista.append(asignatura)
# print row[0], row[1]
row = cursor.fetchone()
cursor.close()
db.close()
return lista
def delMatricula(self, id_matricula):
db = dbParams.conecta()
cursor = db.cursor()
id_matricula = '\'' + id_matricula + '\''
query = "delete from Matricula where id_matricula=" + id_matricula + ";"
if v:
print query
salida = ''
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def delAlumno(self, idAlumno):
#print "Intentado eliminar alumno con dni "+str(dniAlumno)
db = dbParams.conecta(); #La conexión está clara.
cursor = db.cursor()
idAlumno='\''+idAlumno+'\''
query='delete from Alumno WHERE id_alumno='+idAlumno+';'
salida =''
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def delImparte(self, id_imparte):
'''Elimina una tupla imparte de la tabla Imparte'''
db = dbParams.conecta()
cursor = db.cursor()
id_imparte = '\'' + id_imparte + '\''
query = "delete from Imparte where id_imparte=" + id_imparte + ";"
if v:
print query
salida = ''
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def delClase(self, idClase):
if v:
print "Intentado eliminar Clase con id_clase " + str(idClase)
db = dbParams.conecta()
# La conexión está clara.
cursor = db.cursor()
query = "delete from Clase WHERE id_clase=" + idClase + ";"
salida = ""
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def delImparte(self, id_imparte):
'''Elimina una tupla imparte de la tabla Imparte'''
db = dbParams.conecta()
cursor = db.cursor()
id_imparte='\''+id_imparte+'\''
query="delete from Imparte where id_imparte="+id_imparte+";"
if v:
print query
salida =''
try:
salida = cursor.execute(query);
except MySQLdb.Error, e:
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def delClase(self, idClase):
if v:
print "Intentado eliminar Clase con id_clase " + str(idClase)
db = dbParams.conecta()
#La conexión está clara.
cursor = db.cursor()
query = "delete from Clase WHERE id_clase=" + idClase + ";"
salida = ''
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def nuevaClase(self, curso, grupo, nivel):
'''
Introduce una nueva clase en la base de datos. Son necesarios los tres primeros parámetros.
'''
if v:
print apiName
print 'Calling nuevaClase() with params:'
print locals()
db = dbParams.conecta()
#La conexión está clara.
#query="INSERT INTO Curso values("+"'"+nombre+"', "+ "'"+id+"');"
#Añadimos al principio y al final una comilla simple a todos los elementos.
curso = '\'' + curso + '\''
grupo = '\'' + grupo + '\''
nivel = '\'' + nivel + '\''
query = "INSERT INTO Clase VALUES(NULL," + curso + "," + grupo + "," + nivel + ");"
if v:
print '\n' + query
cursor = db.cursor()
#Sacando los acentos...........
mysql_query = "SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
salida = ''
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Clase con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
idClase = ''
try:
salida = cursor.execute(query)
idClase = cursor.lastrowid
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getAsignaturas(self, idClase):
"""
Devuelve una lista con las asignaturas que se dan a esa clase.
Ejemplo:
En 2ºESO se da Frances, Lengua, etc...
Parámetros:
curso, grupo y nivel: identificadores que forman el unívoco de una clase.
Devuelve: Una lista de objetos de tipo asignatura
"""
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query = "SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
idClase = '\'' + idClase + '\''
query = 'select * from Asignatura where id_asignatura in (select id_asignatura from Asocia where id_clase =' + idClase + ')'
if v:
print '\n' + query
cursor.execute(query)
row = cursor.fetchone()
lista = []
while row is not None:
asignatura = Asignatura()
asignatura.id = row[0]
asignatura.nombre = row[1]
lista.append(asignatura)
#print row[0], row[1]
row = cursor.fetchone()
cursor.close()
db.close()
return lista
def postCredenciales(self, idUsuario, nombre, username, password, rol):
'''
Introduce una nueva tupla con la credenciales de algún usuario dado de alta en el sistema.
'''
if v:
print apiName
print ' Calling ' + str(locals()['self'])
print ' ' + str(locals())
#Usamos el gestor para la conexión
db = dbParams.conecta()
#Añadimos al principio y al final una comilla simple a todos los elementos.
idUsuario = '\'' + idUsuario + '\''
username = '******'' + username + '\''
password = '******'' + password + '\''
nombre = '\'' + nombre + '\''
rol = '\'' + rol + '\''
query = 'INSERT INTO Credenciales VALUES(NULL' + ',' + idUsuario + ',' + nombre + ',' + username + ',AES_ENCRYPT(' + password + ',"CLAVESECRETA"),' + rol + ');'
if v:
print ' ' + query + '\n'
cursor = db.cursor()
salida = ''
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Asignatura con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
try:
salida = cursor.execute(query)
except dbParams.MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def delImparteSinClave(self, id_asociacion, id_profesor):
'''Elimina una tupla imparte de la tabla Imparte usando los ides de la asociacion y del profesor,
se usa cuando no se tiene el id de la tupla imparte en concreto.'''
db = dbParams.conecta()
cursor = db.cursor()
id_asociacion = '\'' + id_asociacion + '\''
id_profesor = '\'' + id_profesor + '\''
query = "DELETE FROM Imparte WHERE id_asociacion=" + id_asociacion + " AND id_profesor" + id_profesor + ";"
if v:
print query
salida = ''
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def delAsociacion(self, id_asociacion):
db = dbParams.conecta()
cursor = db.cursor()
id_asociacion = '\'' + id_asociacion + '\''
query = "DELETE FROM Asocia WHERE id_asociacion=" + id_asociacion + ";"
if v:
print query
salida = ''
try:
salida = cursor.execute(query)
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: " + str(e.args[0])
salida = e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def nuevaAsignatura(self, nombre):
if v:
print apiName
print 'Calling nuevaAsignatura() with params:'
print locals()
db = dbParams.conecta() #La conexión está clara.
#query="INSERT INTO Asignatura values("+"'"+nombre+"', "+ "'"+id+"');"
#Añadimos al principio y al final una comilla simple a todos los elementos.
nombre='\''+nombre+'\''
query='INSERT INTO Asignatura VALUES(NULL'+','+nombre+');'
if v:
print query
cursor = db.cursor()
#Sacando los acentos...........
mysql_query="SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
salida =''
'''
Como la ejecución de esta consulta (query) puede producir excepciones como por ejemplo que el Asignatura con clave
que estamos pasando ya exista tendremos que tratar esas excepciones y conformar una respuesta entendible.
'''
idAsignatura=''
try:
salida = cursor.execute(query);
idAsignatura = cursor.lastrowid
except MySQLdb.Error, e:
# Get data from database
try:
print "MySQL Error [%d]: %s" % (e.args[0], e.args[1])
print "Error number: "+str(e.args[0])
salida=e.args[0]
except IndexError:
print "MySQL Error: %s" % str(e)
def getClases(self):
'''
Devuelve una lista con todas las clases registradas en la base de datos.
@future:
Podría pasarse un par de parámetros curso y nivel que por defecto fueran null para aumentar
la flexibilidad de esta clase y que permitiera buscar todas las clases de un nivel o de un curso
en concreto.
'''
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query = "SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
query = "select * from Clase"
if v:
print '\n' + query
cursor.execute(query)
row = cursor.fetchone()
lista = []
while row is not None:
clase = Clase()
clase.id = row[0]
clase.curso = row[1]
clase.grupo = row[2]
clase.nivel = row[3]
lista.append(clase)
#print row[0], row[1]
row = cursor.fetchone()
cursor.close()
db.close()
#Devolvemos la lista al completo.
return lista
def getAlumnos(self, idClase):
'''
Devuelve una lista con los alumnos matriculados en esa clase.
Campos devueltos: id, nombre y apellidos.
'''
db = dbParams.conecta()
cursor = db.cursor()
#Sacando los acentos...........
mysql_query = "SET NAMES 'utf8'"
cursor.execute(mysql_query)
#-----------------------------#
idClase = '\'' + idClase + '\''
'''
Usamos la orden distinct para eliminar los duplicados de una consulta, en este caso id_alumno ya que aparecerá
que un mismo alumno está matriculado muchas veces en un mismo curso con asignaturas disintas, entonces para evitar
contabilizar esos repetidos, usamos esta orden.
'''
#query='SELECT id_alumno, nombre, apellidos FROM Alumno where id_alumno in (select distinct id_alumno from Matricula where id_clase='+idClase+')'
query = 'select id_alumno, nombre, apellidos from Alumno where id_alumno IN (select id_alumno from Matricula where id_asociacion IN (select id_asociacion from Asocia where id_clase=' + idClase + '));'
if v:
print '\n' + query
cursor.execute(query)
row = cursor.fetchone()
lista = []
while row is not None:
alumno = Alumno()
alumno.id = row[0]
alumno.nombre = row[1]
alumno.apellidos = row[2]
lista.append(alumno)
#print row[0], row[1]
row = cursor.fetchone()
cursor.close()
db.close()
return lista