plataforma telemática para la calificación automatizada de...
Post on 04-Oct-2020
2 Views
Preview:
TRANSCRIPT
Goodle GMS
Adrián Muñoz de Dios
Ingeniería de Sistemas y Automática
Escuela Superior de Ingenieros
Universidad de Sevilla
2011
Goodle GMS
Plataforma Telemática para la calificación automatizada de prácticas de asignaturas
universitarias de áreas técnicas
Introducción
Se expone a continuación dos manuales en los que se explican el funcionamiento del
servidor desde diferentes perspectivas. Se distinguen dos partes: Una primera parte
destinada a desarrolladores del servidor, en esta parte se ubica el Manual para el
desarrollador del Servidor de Docencia y una segunda parte destinada a usuarios del
servidor con la categoría profesor, es aquí donde se ubica el Manual para el
profesorado del Servidor de Docencia.
Carlos Sánchez, Fernando Bejarano, el profesor titular Fabio Gómez-Estern y un
servidor son las personas que han trabajado en el servidor en el transcurso de las
diferentes etapas de desarrollo que ha ido sufriendo.
Parte 1: Manual para el desarrollador del Servidor de Docencia
Índice
0. Introducción .................................................................................................................... 8
1. Módulos del Servidor de Docencia .................................................................................. 10
1.1. Index.php .......................................................................................................................... 10
1.2. Carpeta includes ............................................................................................................... 11
1.2.1. System.php ................................................................................................................ 12
1.2.1.1. Tareas .................................................................................................... 13
1.2.1.1.1. Inicio ............................................................................................... 13
1.2.1.1.2. Login (común) ................................................................................. 14
1.2.1.1.3. Logout - Cerrar sesión (común) ...................................................... 16
1.2.1.1.4. RecoverPassword (común) ............................................................. 17
1.2.1.1.5. Destroy (común) ............................................................................. 18
1.2.1.1.6. Profile (común) y ScriptProfile (común) ......................................... 18
1.2.1.1.7. Register (común) y ScriptRegister (común) .................................... 19
1.2.1.1.8. Backup (administrador) .................................................................. 20
1.2.1.1.9. Usuarios (administrador) ................................................................ 21
1.2.1.1.10. AddUser (administrador) .............................................................. 21
1.2.1.1.11. EditUser (administrador) .............................................................. 21
1.2.1.1.12. ScriptUsuario (administrador) ...................................................... 21
1.2.1.1.13. DeleteUser (administrador).......................................................... 22
1.2.1.1.14. Diagnostico_admin (administrador)............................................. 22
1.2.1.1.15. Script_diagnostico_admin (administrador) .................................. 22
1.2.1.1.16. Mostar grupos de alumnos (profesor) ......................................... 23
1.2.1.1.17. EditGrupo (profesor) .................................................................... 23
1.2.1.1.18. Addgrupo (profesor) ..................................................................... 24
1.2.1.1.19. DeleteGrupo (profesor) ................................................................ 25
1.2.1.1.20. AddActividad (profesor) ............................................................... 26
1.2.1.1.21. Actividades (profesor) .................................................................. 27
1.2.1.1.22. EditEstadoActividad (profesor) .................................................... 28
1.2.1.1.23. Veractividad (profesor) ................................................................ 28
1.2.1.1.24. Editaractividad (profesor) ............................................................ 28
1.2.1.1.25. Borraractividad (profesor) ............................................................ 29
1.2.1.1.26. Mostrar asignaciones prácticas - grupos (profesor) .................... 29
1.2.1.1.27. EditPracticas_conjuntosGrupos (profesor) .................................. 29
1.2.1.1.28. AddPracticaGrupo (profesor) ....................................................... 30
1.2.1.1.29. BorrarPracticaGrupo (profesor) ................................................... 30
1.2.1.1.30. AjaxPracticasGruposSubgrupos (profesor) .................................. 30
1.2.1.1.31. ScriptPracticaGrupo (profesor) .................................................... 31
1.2.1.1.32. Editdni (profesor) ......................................................................... 31
1.2.1.1.33. EditPracticasGruposCompartir (profesor) .................................... 32
1.2.1.1.34. Listadnispermitidos (profesor) ..................................................... 33
1.2.1.1.35. EditEstadoAsignacion (profesor) .................................................. 33
1.2.1.1.36. EditEstadoAsigCompartir (profesor) ............................................ 33
1.2.1.1.37. Anadirdni (profesor) ..................................................................... 33
1.2.1.1.38. Borrardni (profesor) ..................................................................... 34
1.2.1.1.39. Scripteditdni (profesor) ................................................................ 34
1.2.1.1.40. ScriptCompartir (profesor) ........................................................... 35
1.2.1.1.41. AddAlumnosGrupo (profesor) ...................................................... 35
1.2.1.1.42. BorrarAlumnosGrupo (profesor) .................................................. 35
1.2.1.1.43. VerAlumnosGrupo (profesor) ....................................................... 36
1.2.1.1.44. ResetPassword (profesor) ............................................................ 36
1.2.1.1.45. ScriptGrupo (profesor) ................................................................. 36
1.2.1.1.46. CompartirPractica (profesor) ....................................................... 36
1.2.1.1.47. Practicas (profesor) ...................................................................... 37
1.2.1.1.48. AddPractica (profesor) ................................................................. 37
1.2.1.1.49. EditPractica (profesor) .................................................................. 37
1.2.1.1.50. ScriptPractica (profesor) ............................................................... 37
1.2.1.1.51. TestPractica (profesor) ................................................................. 38
1.2.1.1.52. AjaxTestPractica (profesor) .......................................................... 38
1.2.1.1.53. ExportPractica (profesor) e importPractica (profesor) ................ 38
1.2.1.1.54. Conjuntos_ejerc (profesor) .......................................................... 39
1.2.1.1.55. Crear_conjunto (profesor) ........................................................... 39
1.2.1.1.56. Mostrar_pract_conjunto (profesor) ............................................. 40
1.2.1.1.57. AddconjuntoGrupo (profesor) ...................................................... 41
1.2.1.1.58. ScriptConjuntoGrupo (profesor) .................................................. 41
1.2.1.1.59. DeleteConjunto (profesor) ........................................................... 41
1.2.1.1.60. Editar_conjunto (profesor) ........................................................... 42
1.2.1.1.61. Script_crear_editar_conjunto (profesor) ..................................... 42
1.2.1.1.62. DeletePractica (profesor) ............................................................. 42
1.2.1.1.63. Diagnostico (profesor) .................................................................. 43
1.2.1.1.64. Reiniciodiagnostico (profesor) ..................................................... 43
1.2.1.1.65. Calificaciones (profesor) ............................................................... 44
1.2.1.1.66. UltimasCalificacionesGrupo (profesor) ........................................ 44
1.2.1.1.67. VerEntrega (profesor) y scriptEditarEntrega (profesor) ............... 44
1.2.1.1.68. Evalua (profesor) y evaluaranking (profesor) ............................... 45
1.2.1.1.69. Historial (alumno) ......................................................................... 46
1.2.1.1.70. EnviarPractica (alumno) ............................................................... 46
1.2.1.1.71. ConsultaPractica (alumno) ........................................................... 47
1.2.1.1.72. ScriptEnviarPractica (alumno) ...................................................... 47
1.2.1.1.73. Deleteadjuntos (alumno) ............................................................. 48
1.2.1.2. Otros métodos auxiliares ...................................................................... 48
1.2.2. Database.php ............................................................................................................ 48
1.2.3. Config.php - Configuración del sistema .................................................................... 51
1.2.4. Alumno.php ............................................................................................................... 52
1.2.5. User.php .................................................................................................................... 54
1.2.6. Menu.php .................................................................................................................. 58
1.2.7. Xtemplate.php – html.php – template.html – Representación de la información por
pantalla ................................................................................................................................ 59
1.2.8. Practica.php ............................................................................................................... 63
1.2.9. Message.php ............................................................................................................. 64
1.2.10. ZipFolder.php .......................................................................................................... 65
1.2.11. Evaluacion.php ........................................................................................................ 65
1.2.12. Procesaejerciciojava.php ......................................................................................... 73
2. Instalación desde cero del servidor de docencia .............................................................. 76
3. Estructura de la Base de Datos ....................................................................................... 78
4. Cómo extender la funcionalidad ..................................................................................... 82
4.1. Modificación de la interfaz – Modificación de la tabla practicas y versiones de la base de
datos ........................................................................................................................................ 82
4.2. Creación de nuevos métodos ........................................................................................... 88
0. Introducción
El presente manual, destinado a desarrolladores del servidor, toma como punto de
partida la explicación del carácter modular del sistema. En éste punto se expone las
claras ventajas del sistema modular y se determina los ficheros php de los diferentes
módulos. El apartado se ordena de acuerdo a la secuencia característica de ejecución
del servidor. El siguiente apartado explica el protocolo y la interfaz concreta para
migrar el servidor de una máquina a otra. Posteriormente, resulta imprescindible
detallar la estructura de la base de datos. Por último, se explica las directrices a tomar
a la hora de extender la funcionalidad del sistema.
Se presenta una aplicación web capaz de proporcionar una innovadora herramienta
educativa diseñada para automatizar la recolección, evaluación y detección de errores
en ejercicios prácticos asignados a estudiantes de ingeniería. El sistema se implementa
en un servidor Apache-PHP-MySQL capaz de gestionar bases de datos y usa Matlab (se
cita, como ejemplo, la evaluación de prácticas tipo Matlab) para comparar una
solución propuesta por un alumno (a través de la ejecución de su código) con la
solución correcta, proporcionando de esta forma las notas de los alumnos
automáticamente. Entre los propósitos del sistema se encuentra el siguiente: Hacer
posible para cada alumno una parametrización o caracterización individual de los
ejercicios. La gran cantidad de posibles arquitecturas existentes en la ejecución de un
código de un alumno permiten llevar a cabo multitud de tests. La plataforma abierta
del sistema permite a un profesor implementar técnicas de enseñanza innovadoras.
Gracias a ellas, el alumno puede obtener información acerca de sus conocimientos
continuamente a lo largo de todo el curso.
El servidor de docencia separa completamente la información de la representación de
ésta, es decir, el servidor se encuentra dividido en una serie de módulos donde la
representación de la información se encuentra en el último lugar. Estos módulos
confieren al servidor de una gran flexibilidad a la hora de generar una nueva versión o
cambiar algún aspecto concreto, evitando tener que acceder y modificar el core del
sistema. La presentación de las páginas es el final de un largo proceso, en el que se van
ejecutando los módulos de forma consecutiva. Este proceso se repite cada vez que se
accede al servidor. Los módulos se pueden dividir, a grandes rasgos, en dos bloques.
Un primer bloque que alberga todos los métodos y funciones necesarias para llevar a
cabo la petición (tarea) que se le está haciendo al servidor. Un segundo bloque
asociado a la representación por pantalla de las diferentes páginas web. Este último
bloque se implementa en XHTML, es decir, páginas web dinámicas.
Existen tres tipos de usuarios en el sistema: Alumnos, profesores y administrador.
Para cada tipo de usuario se establece un menú concreto de tareas. Los alumnos
tienen permitido realizar consultas y modificaciones de su perfil, subir soluciones de
las prácticas que tengan asignadas y que se encuentren activas (en el caso de
encontrarse desactivada tan sólo tienen permitido realizar consultas de la solución
existente en la base de datos), observar las anotaciones del profesor o del evaluador
sobre las soluciones enviadas (siempre y cuando el profesor lo haya configurado así
al crear la práctica) así como las notas y la fecha de finalización de las prácticas. Los
profesores pueden realizar más tareas, entre las más importantes se encuentran:
Creación de grupos/subgrupos (al crear un grupo se debe especificar un fichero Excel
con los alumnos, pues bien, esos alumnos la primera vez que accedan al sistema
deberán registrarse concretando una Clave), crear prácticas, asignar prácticas a
grupos, evaluación de grupos en las prácticas. El administrador del sistema puede
crear administradores y profesores nuevos en el sistema (en este caso al crear un
profesor/administrador, éste ya no tiene que registrarse la primera vez que accede al
sistema), puede realizar un backup del servidor...
El servidor evita el acceso directo a los diferentes scripts a través de la definición de
la constante EXECUTION al comienzo de index.php.
Se presenta a continuación el flujo de trabajo del profesor y del alumno, así como la
interacción existente entre los flujos.
Figura 1: Flujos de trabajo e interacción entre ellos
Las diferentes tareas que pueden llevar a cabo los usuarios vienen recogidas en la
sección de tareas, embebidas en la explicación de los módulos del servidor.
1. Módulos del Servidor de Docencia
En el servidor de docencia la información se trata de manera independiente a la
representación. Para acceder a cualquier página siempre se pasa por una serie de
módulos de manera consecutiva: Se definen constantes del sistema y se incluyen las
clases, se obtiene de configuration.php la configuración del sistema (especificando el
lenguaje), se inicia una nueva sesión, se comprueba si el usuario esta registrado (se
almacena la información del usuario en variables de sesión), se crean todas las posibles
entradas del menú de las páginas, se leen las posibles variables de tipo get y post, se
ejecuta la tarea (generándose la información oportuna), se representa por pantalla la
información generada (a través del relleno y parseo de la plantilla).
1.1. Index.php
El servidor en primer lugar ejecuta index.php. A través de index.php el servidor
establece el valor de una serie de constantes generales del sistema y otras específicas
del idioma, se incluye a modo de librerías la definición de las clases para poder
posteriormente utilizar sus respectivos métodos, se obtiene la configuración del
sistema, se inicia una nueva sesión si no estaba ya iniciada, se crea el menú general, se
leen las variables get y post y se ejecuta la tarea. Como se puede apreciar index.php
alberga a la mayoría de los módulos, de hecho index.php representa el esqueleto
desde el cual, apoyándose en los métodos de las clases, se ordena y se estructura los
módulos del sistema.
Figura 2: Index.php – Módulos del servidor
Finalmente llama al método task de la clase System para realizar las operaciones
específicas de acuerdo a la tarea elegida por el usuario. Una tarea es un trabajo o
acción que se le pide al servidor, como por ejemplo, crear un nuevo grupo.
1.2. Carpeta includes
En esta carpeta se encuentra:
El fichero defines.php: Se encarga de definir constantes necesarias para el
sistema.
El fichero framework.php: Es responsable de realizar las llamadas a las clases.
Index.php
Se definen constantes del sistema
Se incluyen las clases
Se obtiene la configuración del
sistema
Sesión
Se crea menú general
Lectura variables GET y POST
Se ejecuta tarea
Fin
Las diferentes clases existentes.
La carpeta Excel: Alberga todos los scripts necesarios para el manejo de ficheros
Excel, principalmente se utilizará los métodos relacionados con la lectura de
ficheros Excel.
1.2.1. System.php
Este script alberga a la clase System. Se trata de un script muy importante en el core
del sistema ya que en esta clase se encuentra el método task que analiza y ejecuta la
tarea.
Se apoya en métodos que pueden o no pertenecer a la propia clase, por ejemplo, el
método assign_file de la clase Html utilizado para asignar un fichero a la
plantilla usada para la representación por pantalla.
Para poder acceder a los métodos de otras clases desde la clase System se
encuentran definidas una serie de variables que a través de la función constructora
apuntan (punteros) a objetos pertenecientes a estas clases. De forma análoga, a través
del uso de punteros, es posible el acceso a métodos pertenecientes a la clase System
desde un objeto de otra clase diferente a System, es decir, en sentido contrario al
explicado antes.
El método task de la clase System ejecuta la tarea que el usuario haya elegido.
vars es un vector definido en la clase, la tarea asignada se encuentra en la posición
task del vector vars. El usuario, al seleccionar una entrada, del menú lateral por
ejemplo, esta eligiendo una tarea. Esta tarea es recuperada a través de las variables
tipo Get y Post. El método getVars se encarga de recuperar los valores de las
variables tipo Get y Post almacenándolos en las posiciones adecuadas de vars. A
continuación se muestra un diagrama de flujo del método task.
Figura 3: Diagrama de flujo del método task ejecución tarea
En primer lugar se comprueba si ha sido elegida alguna tarea. En caso afirmativo, se
comprueba si el usuario tiene o no permiso para ello. Se distingue entre tareas
comunes a todos los usuarios, tareas del administrador, tareas de los profesores y
tareas del alumno. Si el usuario tiene permiso para la tarea que solicita se ejecuta la
tarea deseada.
1.2.1.1. Tareas
En el caso de que se acceda a index.php sin pasarle al servidor ninguna variable a
través de Get y Post (formulario o mediante URL), el método getVars se encarga
de asignar la tarea inicio. Se corresponde con la etapa inicial, el usuario se conecta
con el servidor mostrando éste la página en la que se invita al usuario a identificarse a
través de su DNI y Clave de usuario. Si el usuario se ha identificado previamente en el
sistema y al salir de él no cerró su sesión, el servidor cargará la página de bienvenida
directamente, saltándose el paso de identificación, debido a que no se eliminaron las
variables de sesión asociadas a la conexión.
1.2.1.1.1. Inicio
Function task
Sí
Sí
Switch(vars[task])
Case
inicio
Case
scriptEnviarPractica .....
Default
error
No
No
Error
¿Existe
vars[task]?
¿Tiene permiso el
usuario?
Fin
.....
La tarea inicio pertenece al grupo de tareas comunes a todos los usuarios. Se
distinguen dos casos: Un primer caso en el que el usuario no ha iniciado sesión y un
segundo caso en el que el usuario sí lo ha hecho.
Primer caso: Se le ofrece al usuario la posibilidad de iniciar sesión, mostrándole un
formulario a cumplimentar con su DNI y Clave de usuario.
Figura 4: Formulario para iniciar sesión
Segundo caso: El usuario posee una sesión abierta en el sistema, el servidor
muestra por pantalla una página en la que se le da la bienvenida. Se establece el
menú lateral con las opciones correspondientes a su perfil de usuario.
Figura 5: Página de bienvenida
1.2.1.1.2. Login (común)
La tarea login verifica que los campos del formulario para iniciar sesión, DNI y
Clave de usuario, estén rellenos al pulsar Enviar.
Si un usuario, registrado en el sistema, ha marcado la casilla recuérdame en
anteriores conexiones con el servidor tendrá las cookies creadas en su ordenador,
siempre y cuando al salir del sistema no haya cerrado sesión. Ésto conlleva el acceso
directo al servidor sin pasar por la identificación en el sistema. Es el método start de
la clase User, el encargado de desempeñar esta función. El usuario debe tener la
precaución de cerciorarse de que las cookies estén habilitadas en su ordenador. Por
otro lado, destacar que las cookies tienen un tiempo de duración configurable (script
configuration dentro de la carpeta configuration).
La opción recuérdame sólo está disponible para los usuarios de tipo profesor o
administrador.
En el caso de que los campos de identificación no hayan sido rellenados
correctamente, se mostrará por pantalla un error, invitando al usuario a volver a
rellenar el formulario.
Figura 6: Error debido a campos no rellenos al iniciar sesión
En caso contrario, se comprueba si el usuario está registrado en la base de datos del
servidor. Si no se obtiene coincidencias en la base de datos o hay alguna otra
anomalía, como por ejemplo más de un usuario con el mismo DNI y Clave de usuario,
se muestra un error por pantalla. Si el usuario está registrado en el sistema se rellenan
las variables de sesión y se accede al sistema. Si además, ha marcado la opción
recuérdame, siempre y cuando sea profesor o administrador, se crean las cookies
dni, clave y categoría correspondientes para posteriores conexiones.
Figura 7: Error debido a campos rellenados incorrectamente al iniciar sesión
1.2.1.1.3. Logout - Cerrar sesión (común)
La tarea logout cierra la sesión del usuario.
Inicialmente muestra por pantalla una página de confirmación. En caso de confirmar,
se ejecuta el método logout de la clase User. Este método realiza dos operaciones:
Destruir la sesión: Elimina las variables de sesión y todos sus datos almacenados.
Borrar las cookies dni, clave y categoría.
Finalmente el servidor muestra por pantalla el formulario para identificarse el usuario.
En caso contrario, se ejecuta un método en JavaScript
(javascript:history.go(-1)). Gracias al cual, se vuelve a la página
anteriormente visitada, aprovechando el historial del navegador.
Figura 8: Página de confirmación de cierre de sesión
1.2.1.1.4. RecoverPassword (común)
La tarea recoverPassword permite que un usuario, registrado en el sistema,
pueda recuperar su Clave de usuario en caso de olvido.
Inicialmente, se muestra un formulario para que el usuario introduzca su dirección de
correo electrónico y su DNI. Al pulsar Enviar, se hace una consulta a la base de datos
para localizar un usuario (se busca al usuario en la categoría de profesor y de alumno)
que tenga los datos introducidos. Si se identifica al usuario, el servidor le manda un
correo con su Clave de usuario. En caso contrario, se muestra un error por pantalla.
Figura 9: Formulario a rellenar para recuperar la Clave de usuario
Figura 10: Error debido a usuario inexistente al recuperar la Clave de usuario
1.2.1.1.5. Destroy (común)
La tarea destroy permite vaciar y eliminar las variables de sesión. Finalmente, se
redirecciona a index.php.
1.2.1.1.6. Profile (común) y ScriptProfile (común)
Estas tareas permiten actualizar el perfil del usuario en el servidor.
En primer lugar se ejecuta profile, mostrando los datos del usuario. Se distingue
entre usuario perteneciente a la categoría alumno o a la categoría
profesor/administrador, ya que los campos del formulario cambian.
Una vez realizadas las modificaciones pertinentes en los campos del formulario, el
usuario puede realizar dos operaciones:
Subir los cambios realizados al servidor: Pulsar Grabar. En este caso, se ejecuta la
tarea ScriptProfile, responsable de subir los datos del formulario a la tabla
correspondiente de la base de datos (se distingue entre profesor/administrador
y alumno). Finalmente, se muestra la página de bienvenida indicando que el
perfil ha sido actualizado correctamente, a través de un mensaje.
No almacenar los cambios en el servidor: Pulsar Cancelar. En este caso, se
volvería a la página anteriormente visitada a través del método
javascript:history.go(-1).
La información del perfil de los usuarios se almacena en dos tablas de la base de datos.
La distinción se hace, en función de la categoría a la que pertenezcan:
Tabla con los perfiles de los alumnos.
Tabla con los perfiles de los profesores y administradores.
Figura 11: Formulario para actualizar el perfil
Figura 12: Perfil actualizado correctamente
1.2.1.1.7. Register (común) y ScriptRegister (común)
Estas tareas permiten que un usuario de la categoría alumno se registre en el sistema.
Gracias a ellas, el usuario establece su Clave de usuario (Clave que tendrá que
introducir, junto con su DNI, cada vez que quiera acceder al sistema) y su dirección de
correo electrónico. Para poder llevar a cabo correctamente el proceso de registro, el
alumno debe haber sido dado de alta en algún grupo previamente (tarea llevada a
cabo por el profesor responsable del grupo).
En primer lugar, se ejecuta register. Esta tarea muestra el formulario de registro
del alumno.
El alumno debe rellenar adecuadamente el formulario y pulsar Enviar, momento en
el que se ejecuta scriptRegister. En primer lugar, la tarea comprueba si el DNI
introducido pertenece a algún alumno (realiza una consulta en la tabla alumnos de la
base de datos). Puede darse dos situaciones:
No existe ningún registro en la tabla alumnos con el DNI introducido: Se muestra
un mensaje de error.
Existe un único registro en la tabla alumnos con el DNI introducido: Se comprueba
que el registro tenga los campos email y clave vacíos. Si los campos no se
encuentran vacíos, se muestra un mensaje de error. En caso contrario, se
actualiza el registro con la Clave y la dirección de correo introducida, mostrando
finalmente un mensaje de registro correcto.
1.2.1.1.8. Backup (administrador)
Esta tarea permite realizar un backup del directorio de trabajo. El backup contempla:
Ficheros de enunciados.
Ficheros de utilidades.
Ficheros adjuntos.
Base de datos completa.
La tarea muestra inicialmente una página en la que se especifica qué incluye el backup.
Al pulsar Aquí, se procede a realizar la copia de seguridad. Los pasos son los
siguientes:
Se crea un fichero Zip en temp, cuyo nombre es backup más la fecha en la que se
realice el backup. Si no se puede abrir, se abandona la tarea y se muestra un
mensaje de error
Se comprime la carpeta practicas. Se añade la carpeta comprimida al fichero Zip
en temp, con el nombre practicas.zip.
Se lee la configuración de la base de datos y la ruta a mysqldump.
Se ejecuta mysqldump, gracias al cual, se consigue realizar un backup de la base
de datos en la carpeta temp.
Se añade el backup de la base de datos al fichero Zip de la carpeta temp. Se
elimina el backup de la base de datos que se encuentra en la carpeta temp.
Finalmente, se manda por el navegador el fichero Zip.
1.2.1.1.9. Usuarios (administrador)
Muestra una tabla con información (por ejemplo: DNI, Email...) acerca de los
profesores y administradores del sistema.
En la tabla se puede ver una columna llamada OPCIONES, en la que aparece diversas
acciones a realizar sobre los usuarios:
Editar el perfil de algún profesor o administrador.
Borrar algún profesor o administrador.
1.2.1.1.10. AddUser (administrador)
Permite añadir un nuevo profesor o administrador al sistema. Para tal fin, esta tarea
muestra un formulario específico.
1.2.1.1.11. EditUser (administrador)
Permite modificar el perfil de un profesor o administrador.
Se muestra un formulario con los datos del perfil del profesor o administrador
(previamente, se ha tenido que realizar una consulta a la base de datos, para obtener
el perfil). El administrador puede modificar los diversos campos del formulario. Al
pulsar Grabar, se actualiza el perfil en la base de datos.
1.2.1.1.12. ScriptUsuario (administrador)
Procesa la información existente en los formularios mostrados en las tareas adduser
y edituser.
La tarea se ejecuta al pulsar Grabar. Dos situaciones posibles:
Se está añadiendo un nuevo profesor o administrador: Se llama al método
insert (perteneciente a la clase database). Este método inserta un vector
en la tabla usuarios de la base de datos. El vector almacena en sus diversas
posiciones la información introducida en el formulario.
Se está editando un profesor o administrador existente: Se llama al método
update (perteneciente a la clase database). Este método actualiza un
registro determinado (a partir del campo id de la tabla usuarios) de la tabla
usuarios, con las modificaciones en el perfil introducidas a través del formulario.
Finalmente, se muestra la tabla con todos los profesores y administradores del
sistema. En la parte superior se aprecia un mensaje, indicando que el usuario ha sido
añadido con éxito o que el perfil del usuario se ha actualizado con éxito, según
corresponda.
En los formularios, se ofrece la posibilidad de no ejecutar la tarea, volviendo a la
página anteriormente visitada. Para ello se debe pulsar cancelar (se ejecuta el
método javascript:history.go(-1)).
1.2.1.1.13. DeleteUser (administrador)
Permite eliminar un profesor o administrador del sistema.
Primeramente, se muestra una página de confirmación. En caso afirmativo, se elimina
al usuario de la tabla usuarios. Para borrar en la tabla al usuario adecuado, se utiliza el
campo id. Finalmente, se muestra la tabla con todos los profesores y administradores
del sistema, apareciendo en la parte superior un mensaje indicando que el usuario ha
sido borrado con éxito. En caso contrario, se vuelve a la página anteriormente visitada,
a través del método javascript:history.go(-1).
1.2.1.1.14. Diagnostico_admin (administrador)
Permite saber el estado en el que se encuentra el servidor Matlab. El servidor se puede
encontrar ocupado realizando una evaluación, colgado (bucles infinitos presentes en el
código) o corriendo (listo para lanzar una nueva evaluación).
Mientras se realiza la consulta del estado del servidor, se muestra un mensaje por
pantalla indicando que se está ejecutando el diagnóstico. Para ello, se muestra la
página con el mensaje y se redirecciona nuevamente a la tarea
diagnostico_admin (la redirección se lleva a cabo en JavaScript, gracias al script
mensaje_carga_pagina.js) para evaluar el estado y mostrar la página correspondiente.
Para determinar el estado, se manda al servidor Matlab, a través de la pasarela TCP, el
comando ver. La conexión socket (conexión entre el servidor PHP y el servidor TCP de
comunicación con Matlab) se configura con un tiempo de espera de lectura igual a
cinco segundos. Como consecuencia, se determina una espera máxima de cinco
segundos desde que se ordena la lectura del socket hasta que se recibe algo de él.
Finalmente, se lee la respuesta de Matlab. Si no se obtiene respuesta, el servidor no ha
ejecutado el comando debido a que está ocupado o colgado, en caso contrario, el
servidor está corriendo.
Estado corriendo: Se informa de que el estado del servidor es corriendo.
Estado ocupado o colgado: Se informa de que el estado del servidor es ocupado o
colgado. Se ofrece la posibilidad de forzar un reinicio del servidor.
1.2.1.1.15. Script_diagnostico_admin (administrador)
Lleva a cabo el reinicio del servidor Matlab. Al realizar la consulta del estado del
servidor, si éste se encuentra ocupado o colgado se ofrece la posibilidad de forzar un
reinicio del servidor, siendo esta tarea la responsable de ello.
Inicialmente se muestra por pantalla una página de confirmación. En caso de
confirmar, se muestra por pantalla un mensaje invitando a que pasados unos segundos
el administrador reinicie el navegador, el motivo es que el navegador se queda colgado
en el momento en el que se fuerza el reinicio del servidor. Al mostrar la página, se
redirecciona nuevamente a la tarea script_diagnostico_admin (la redirección
se lleva a cabo en JavaScript, gracias al script mensaje_carga_pagina.js). Es en esta
ejecución de la tarea cuando se realiza propiamente el reinicio del servidor. El
procedimiento para reiniciar el servidor es el siguiente:
Se manda la orden finalizar la aplicación Matlab.
Se manda la orden finalizar la aplicación servidor TCP (puente de comunicación
con Matlab).
Se para la ejecución del script un tiempo prudencial por seguridad, así se asegura
que las ordenes anteriores se han llevado a cabo correctamente.
Se manda la orden arranque del servidor TCP (dicho servidor gestiona y se
comunica con Matlab).
Se observa que el procedimiento es análogo al que se lleva a cabo al finalizar una tarea
mediante el administrador de tareas de Windows.
1.2.1.1.16. Mostar grupos de alumnos (profesor)
Cada profesor posee una serie de grupos a su cargo, esta tarea muestra una tabla con
estos grupos. Se muestra información relativa a los diferentes grupos, por ejemplo,
número de subgrupos que posee un grupo.
En la columna OPCIONES, se muestran diversas acciones a realizar sobre los grupos:
Añadir alumnos a un grupo.
Asignar una práctica a un grupo.
Editar un grupo.
Borrar un grupo.
1.2.1.1.17. EditGrupo (profesor)
Permite editar un grupo existente.
Se muestra un formulario con los datos del grupo. Previamente, se ha tenido que
realizar una consulta a la base de datos para obtener los datos del grupo. El profesor
puede modificar los campos, actualizándolos con la información correcta.
En caso de querer formalizar los cambios, se debe pulsar Grabar. En caso contrario, se
pulsa Cancelar. En este último caso, se ejecuta el método
javascript:history.go(-1).
Sólo se permite editar un grupo, en ningún caso se permite acceder a los subgrupos
que pueda poseer el grupo.
1.2.1.1.18. Addgrupo (profesor)
Permite crear nuevos grupos.
Se presenta al profesor un formulario a rellenar con la información del nuevo grupo.
Mostrando finalmente, dos opciones:
Confirmar y guardar el nuevo grupo: Se debe pulsar Grabar.
Rechazar y no guardar el nuevo grupo: Se debe pulsar Cancelar. En este caso, se
vuelve a la página anteriormente visitada a través del método
javascript:history.go(-1).
A la hora de crear un nuevo grupo, se debe especificar los alumnos que compondrán el
grupo. En el formulario existe un campo para detallar la ruta a un fichero de texto
plano separado por punto y coma (formato CSV). En este fichero, se debe escribir los
alumnos que compondrán el grupo. Se trata de un fichero Excel encabezado por D.N.I.,
es decir, los alumnos deben aparecer a partir de la fila siguiente a la que contenga el
encabezado señalado. La información de cada alumno se escribe en una fila.
Apareciendo en la primera columna el DNI y en la segunda el nombre.
El encabezado es configurable, tan sólo hay que especificar su valor en el script
configuration.php.
Sólo se permite crear nuevos subgrupos de un grupo a la hora de añadir alumnos a un
grupo creado previamente.
Los subgrupos ofrecen dinamismo al grupo. Permiten agrupar, en base a algún criterio,
los alumnos del grupo. Esta clasificación se hace efectiva a la hora de asignar prácticas,
a cada subgrupo se le puede asignar prácticas distintas. A la hora de evaluar, se evalúa
a los alumnos de cada subgrupo en prácticas diferentes ya que las asignaciones varían
de un subgrupo a otro. Un posible caso práctico sería el siguiente: Un profesor imparte
una asignatura de una titulación que se hace corresponder con un grupo concreto, la
asignatura la imparte en varias clases de la escuela. En este caso, sería muy
recomendable crear subgrupos que se correspondan con cada una de las clases. De
manera que, el profesor pueda cambiar las prácticas que asigna a cada una de las
clases.
1.2.1.1.19. DeleteGrupo (profesor)
Permite eliminar un grupo.
Inicialmente, esta tarea analiza el estado del grupo que se desea eliminar. Es decir,
determina:
Si el grupo posee prácticas asignadas y alumnos: No es posible eliminar el grupo,
ya que posee prácticas asignadas. Se muestra un mensaje por pantalla indicando
el estado del grupo y la imposibilidad de eliminarlo. Finalmente, se debe pulsar
Aceptar para volver a la página anteriormente visitada, se ejecuta el método
javascript:history.go(-1).
Si posee únicamente prácticas asignadas: No es posible eliminar el grupo, ya que
posee prácticas asignadas. Se procede de igual forma que en el caso anterior.
Si posee únicamente alumnos: Es posible eliminar el grupo. Se muestra un
mensaje por pantalla indicando el estado del grupo. Se ofrece la posibilidad de
confirmar la eliminación (pulsar Sí) o rechazarla (pulsar No). Para este último
caso, se ejecuta el método javascript:history.go(-1). Para eliminar el
grupo, primeramente, se borra el grupo de la tabla grupos (tabla con la
información de los grupos). Posteriormente, se elimina el grupo de la tabla
usuarios_grupos (especifica a qué profesor pertenece cada grupo). Tras ello, se
procede a eliminar a aquellos alumnos del grupo que pertenezcan
exclusivamente a este grupo (tabla alumnos). Para tal fin, se realizan consultas a
la tabla grupos_alumnos (muestra a qué grupo/s pertenece cada alumno,
indicando también el subgrupo). Finalmente, tras borrar el grupo de la tabla
grupos_alumnos, se redirecciona a la página en la que se muestra una tabla con
todos los grupos existentes.
Si no posee alumnos ni prácticas asignadas: Es posible eliminar el grupo. Se
muestra un mensaje por pantalla indicando el estado del grupo. Se ofrece la
posibilidad de confirmar la eliminación (pulsar Sí) o rechazarla (pulsar No). Para
este último caso, se ejecuta el método javascript:history.go(-1).
Para eliminar el grupo, inicialmente, se borra el grupo de la tabla grupos. Tras
ello, se elimina el grupo de la tabla usuarios_grupos. Por último, se redirecciona
a la página en la que se muestra una tabla con todos los grupos existentes.
En el caso de que se proceda a eliminar un grupo que posea subgrupos, si los
subgrupos no poseen prácticas asignadas, el grupo podrá ser eliminado arrastrando en
la eliminación todos los subgrupos que albergue. Tratando la eliminación de alumnos
de manera análoga a la comentada: Serán borrados aquellos alumnos del grupo
(incluyendo los subgrupos) que no pertenezcan a ningún otro grupo o subgrupo de
éste último, si lo tuviera.
1.2.1.1.20. AddActividad (profesor)
Permite crear una actividad (suscripción). Muestra los formularios correspondientes a
los diferentes pasos en los que se divide la creación de una actividad y almacena
adecuadamente la información en la base de datos. Pasos:
Paso 1: Seleccione un grupo: Permite seleccionar el grupo al que
pertenece la actividad. Admite la elección de un subgrupo concreto del grupo.
Figura 13: Formulario paso 1: Selección grupo - subgrupo
Paso 2: Crear nueva actividad: Crea una nueva actividad. Se especifica
sus principales características, por ejemplo: Número de alumnos por turno,
nombre y descripción de la actividad o fecha inicial - final. Se permite crear
sesiones de manera automática. Con esta opción, se establecen algunos
parámetros por defecto, disminuyendo el tiempo empleado en la creación de la
actividad.
Figura 14: Formulario paso 2: Creación actividad (modo manual)
A continuación, se establece el horario de los diferentes turnos, los días de la
semana con actividad, fechas puntuales en las que no hay actividad y finalmente
se genera un cuadrante provisional con todas las sesiones de la actividad. En el
cuadrante, se muestra información de cada sesión, además, se permite editar o
borrar una sesión.
Esta sección está en desarrollo y puede sufrir cambios importantes.
En la transacción de un paso a otro se guarda la información introducida en los
formularios en unas tablas provisionales (actividades_prov, sesiones_prov,
turnos_prov…). Es en el último momento, al confirmar el cuadrante, cuando se
traspasa todos los registros de las diferentes tablas provisionales a los respectivos
registros de las tablas homogéneas. Permite el movimiento de un paso a otro sin
perder la información introducida en los formularios, además si el profesor decide no
finalizar la creación de la actividad no se registrará en las tablas definitivas evitando
que quede constancia alguna.
1.2.1.1.21. Actividades (profesor)
Lista en una tabla todas las actividades pertenecientes al profesor identificado en el
sistema. Muestra información de cada actividad (estado, nombre, grupo, subgrupo,
número de sesiones, número de alumnos inscritos…) y permite editar y borrar una
actividad, además ofrece la posibilidad de ver sus sesiones.
Figura 15: Lista de actividades
1.2.1.1.22. EditEstadoActividad (profesor)
Permite editar el estado de una actividad. Al pulsar en el estado de una actividad se
llama a esta tarea invirtiendo el estado de la actividad. Una actividad puede presentar
un estado activo o inactivo. Si la actividad presenta estado inactivo no será mostrada a
los alumnos del grupo asociado.
1.2.1.1.23. Veractividad (profesor)
Permite ver las sesiones que posee una determinada actividad. Se lista en una tabla las
sesiones y se muestra las principales características de cada sesión.
Figura 16: Sesiones pertenecientes a una actividad
1.2.1.1.24. Editaractividad (profesor)
Permite editar una determinada actividad.
Figura 17: Edición de una actividad
1.2.1.1.25. Borraractividad (profesor)
Permite borrar una determinada actividad.
1.2.1.1.26. Mostrar asignaciones prácticas - grupos (profesor)
Cada asignación establece una tarea (práctica) que debe realizar un grupo o un
subgrupo concreto (fijando características como la fecha final de entrega, si se desea
mostrar al alumno los comentarios del profesor…).
Se muestra todas las asignaciones entre prácticas y grupos o entre prácticas y
subgrupos que el profesor haya establecido. Una práctica se puede asociar a cualquier
grupo que el profesor tenga definido o a cualquier subgrupo perteneciente a un grupo
(en aquellos grupos, en los que hay a su vez, subgrupos definidos).
De manera análoga, se muestra al final de la tabla todas las asignaciones entre
conjuntos de ejercicios y grupos o entre conjuntos de ejercicios y subgrupos que el
profesor haya establecido. Los conjuntos de ejercicios permiten agrupar las prácticas
que el profesor vea oportunas, tratándolas como un único bloque a la hora asignarlas a
grupos o de lanzar evaluaciones. Es una forma de facilitar la tarea del profesor en
situaciones en las que debe asignar varias prácticas a grupos, pudiendo ser el número
de éstas elevado, ahorrando un importante tiempo.
1.2.1.1.27. EditPracticas_conjuntosGrupos (profesor)
Esta tarea permite editar una asignación práctica - grupo o práctica - subgrupo, según
corresponda, si la asignación seleccionada incumbe a una práctica. Si la asignación
seleccionada incumbe a un conjunto de ejercicios, la tarea permite editar dicha
asignación conjunto de ejercicios - grupo o conjunto de ejercicios - subgrupo.
Las características de una asignación serán las mismas, tanto si la asignación incumbe a
una única práctica o por contrario a un conjunto de ejercicios.
1.2.1.1.28. AddPracticaGrupo (profesor)
Permite realizar una nueva asignación práctica/conjunto de ejercicios - grupo o
práctica/conjunto de ejercicios - subgrupo, según corresponda.
Al listar los grupos existentes, en la columna OPCIONES se ofrece la posibilidad al
profesor de realizar una nueva asignación. De forma análoga, también se ofrece esta
posibilidad al listar los ejercicios.
Si un profesor no posee algún grupo, no se le permite asignar prácticas/conjuntos de
ejercicios.
1.2.1.1.29. BorrarPracticaGrupo (profesor)
Permite borrar una asignación práctica/conjunto de ejercicios - grupo o
práctica/conjuntos de ejercicios - subgrupo, según corresponda.
Para que el borrado pueda llevarse a cabo, es necesario que no se haya realizado
entrega alguna por parte de algún alumno.
En caso de no cumplir con esta premisa, no se efectúa el borrado. Se muestra un
mensaje por pantalla indicando el motivo. Si se cumple, se borra la asignación elegida y
se muestra un mensaje, indicando que la operación de borrado ha tenido éxito.
Un profesor que realiza una asignación, puede autorizar a otros profesores a editar la
asignación. Si el profesor decide borrar la asignación, se borran automáticamente las
posibles autorizaciones que hubiera.
1.2.1.1.30. AjaxPracticasGruposSubgrupos (profesor)
Se encarga de rellenar el combo subgrupos cada vez que se actualiza el combo grupos.
Por combo se entiende el menú desplegable que aparece, por ejemplo, al asignar una
práctica a un grupo. Al seleccionar un grupo, a través del script practicaGrupo.js
(JavaScript), se lanza esta tarea. La cual se encarga de realizar una consulta a la base de
datos para obtener los subgrupos que posea el grupo seleccionado. Finalmente,
actualiza el combo subgrupos con dicha información.
Figura 18: Menú desplegable para seleccionar el subgrupo
1.2.1.1.31. ScriptPracticaGrupo (profesor)
Se encarga de procesar correctamente la información introducida en los formularios
de las tareas editPracticas_conjuntosGrupos y addPracticaGrupo.
Hay que saber si la asignación creada o editada está vinculada a una práctica o a un
conjunto de ejercicios. Para resolverlo, se mira el contenido de la variable vars,
concretamente la posición practicasid. Contendrá el identificador de la
práctica/conjunto de ejercicios seguido de un uno si es el identificador de un conjunto
de ejercicios o de un cero en caso contrario.
La tarea permite insertar una nueva asignación práctica/conjunto de ejercicios - grupo
o editar una asignación práctica - grupo. La tarea responsable de procesar
correctamente la información asociada a la modificación de una asignación conjuntos
de ejercicios - grupo es scriptConjuntoGrupo.
1.2.1.1.32. Editdni (profesor)
Permite editar un DNI de la lista de profesores a los que se les permiten modificar una
determinada asignación.
Un profesor a la hora de crear una asignación puede permitir que ciertos profesores
tengan permiso para modificar determinados aspectos de la asignación. Se especifica
los DNIs de dichos profesores separados por un espacio en blanco.
La tarea editdni muestra un formulario con el DNI a editar. Tras realizar la
modificación pertinente, el profesor puede pulsar Cancelar y volver a la página
anteriormente visitada o pulsar Grabar y hacer definitivos los cambios.
Figura 19: Editar DNI perteneciente a la lista de profesores autorizados
Al pulsar Grabar se ejecuta la tarea scripteditdni, se encarga de almacenar
adecuadamente en la base de datos la modificación realizada.
1.2.1.1.33. EditPracticasGruposCompartir (profesor)
Permite editar una asignación como profesor autorizado. Muestra el formulario relleno
con los datos de la asignación.
Tras realizar los cambios oportunos, el profesor puede pulsar Cancelar y volver a la
página anteriormente visitada o pulsar Grabar y hacer definitivos los cambios
realizados. Para ello, se ejecuta la tarea scriptCompartir, encargada de
almacenar adecuadamente en la base de datos los cambios realizados.
Figura 20: Edición de una asignación como profesor autorizado
Se distingue si se está ante una asignación práctica - grupo o conjunto - grupo, ya que
se accede a tablas distintas.
1.2.1.1.34. Listadnispermitidos (profesor)
Lista en una tabla los DNIs de los profesores a los que se les permiten modificar una
asignación concreta.
La tarea permite además, editar, borrar y añadir un nuevo DNI.
Se diferencia si se está ante una asignación de tipo práctica - grupo o conjunto - grupo,
ya que la tabla en donde buscar los DNIs permitidos cambia.
Figura 21: Lista de DNIs de profesores autorizados
1.2.1.1.35. EditEstadoAsignacion (profesor)
Permite editar el estado de una asignación. Al pulsar en el estado de una asignación se
llama a esta tarea invirtiendo su estado. Una asignación puede presentar un estado
activo o inactivo. Si la asignación presenta estado inactivo no será mostrada a los
alumnos del grupo asociado.
Se distingue entre asignaciones de tipo práctica - grupo y conjunto - grupo, ya que las
tablas donde se encuentra el campo estado son diferentes en cada caso.
1.2.1.1.36. EditEstadoAsigCompartir (profesor)
Lleva a cabo la misma función que la tarea editEstadoAsignacion, dentro del
contexto de las asignaciones como profesor autorizado.
1.2.1.1.37. Anadirdni (profesor)
Permite añadir un nuevo DNI a la lista de profesores a los que se les permiten
modificar una determinada asignación.
La tarea muestra un formulario a rellenar con el nuevo DNI, si se desea volver a la
página anteriormente visitada se debe pulsar Cancelar, en caso contrario, pulsar
Grabar. En este último caso, se llama al método scripteditdni, el cual actualiza
adecuadamente la base de datos con el nuevo DNI introducido.
Figura 22: Añadir un nuevo profesor autorizado
1.2.1.1.38. Borrardni (profesor)
Permite borrar un DNI de la lista de profesores a los que se les permiten modificar una
determinada asignación.
En vars['posicion'] se tiene la posición que ocupa en el array el DNI que se
desea borrar. Se realiza una consulta a la tabla practicas_grupos o conjuntos_grupos,
dependiendo si se está ante una asignación práctica - grupo o conjunto - grupo. El id de
la asignación se tiene en vars['id']. Se obtiene el campo dnispermitidos. Se
transforma el texto en un array (en cada posición del array se tendrá un DNI). Se borra
del array la posición concreta indicada por vars['posicion'].
Finalmente, se actualiza la tabla practicas_grupos o conjuntos_grupos, según proceda,
se borra de la tabla usuarios_asignaciones al profesor que se desea borrar de la lista
(siempre y cuando el DNI corresponda a algún profesor registrado en el sistema) y se
redirecciona nuevamente a la tabla con la lista de DNIs.
1.2.1.1.39. Scripteditdni (profesor)
Responsable de almacenar adecuadamente en la base de datos los datos introducidos
por el profesor en los formularios asociados a las tareas anadirdni y editdni.
Añadir un nuevo DNI: Se distingue entre una asignación de tipo práctica - grupo o
conjunto - grupo. Se obtiene los DNIs permitidos, se añade el nuevo DNI,
previamente se añade el espacio en blanco de separación (en el caso de que ya
haya más DNIs, al menos uno, si es el primero no hay que añadir espacio en
blanco al principio) y se actualiza las tablas practicas_grupos o conjuntos_grupos
según corresponda y usuarios_asignaciones (siempre y cuando el DNI
introducido corresponda a un profesor registrado en el sistema). Finalmente, se
redirecciona a la página que muestra la lista de DNIs.
Editar DNI existente: Se distingue entre una asignación de tipo práctica - grupo o
conjunto - grupo. Se obtiene los DNIs permitidos. Se modifica el DNI, para ello, se
vuelca en un array los DNIs separados por espacios y se accede al DNI que se
quiere modificar a través de vars['posicion'] (determina la posición en el
array). Se borra de la tabla usuarios_asignaciones la entrada asociada al DNI
antiguo sin modificar, se añade una nueva entrada en la tabla
usuarios_asignaciones con el DNI modificado (siempre y cuando el DNI
modificado corresponda a un profesor registrado en el sistema). Se actualiza la
tabla practicas_grupos o conjuntos_grupos según corresponda. Finalmente, se
redirecciona a la página que muestra la lista de DNIs.
1.2.1.1.40. ScriptCompartir (profesor)
Responsable de almacenar adecuadamente en la base de datos los datos introducidos
por el profesor en el formulario asociado a la tarea
editPracticasGruposCompartir.
Hay que diferenciar si se está ante una asignación práctica - grupo o conjunto - grupo,
ya que las tablas que se deben actualizar son diferentes (practicas_grupos o
conjuntos_grupos). Finalmente, se redirecciona a la página en la que se lista todas las
asignaciones compartidas que tiene el profesor.
1.2.1.1.41. AddAlumnosGrupo (profesor)
Permite añadir alumnos a un grupo.
El grupo puede tener varios subgrupos ya creados. Se permite elegir el subgrupo al que
va a pertenecer el nuevo alumno o incluso asignarle un nuevo subgrupo.
La tarea admite dos posibilidades:
Añadir manualmente alumnos, de uno en uno.
Añadir todos los alumnos que figuren en un fichero de texto plano separado por
punto y coma (formato CSV) automáticamente: Las características que debe
poseer el fichero, son las explicadas en la tarea addgrupo.
1.2.1.1.42. BorrarAlumnosGrupo (profesor)
Permite borrar una serie de alumnos (seleccionados previamente) del grupo al que
pertenezcan.
Sólo se pueden borrar aquellos alumnos que no hayan realizado entregas.
Si dentro de los alumnos seleccionados, hay alumnos que han realizado entregas, se
procede de la siguiente manera:
Los alumnos que han realizado entregas, no son eliminados. Se muestra por
pantalla un mensaje de error.
Los alumnos que no han realizado entregas, son eliminados de la tabla
grupos_alumnos.
Finalmente, se actualiza el número de subgrupos que posee el grupo, ya que durante
el proceso de borrado han podido desaparecer subgrupos. Esta situación ocurre al
eliminar todos los alumnos pertenecientes a un subgrupo.
1.2.1.1.43. VerAlumnosGrupo (profesor)
Muestra todos los alumnos pertenecientes a un grupo, incluyendo los diversos
subgrupos que puedan existir.
1.2.1.1.44. ResetPassword (profesor)
Permite resetear la Clave de usuario de algún alumno.
A cada alumno registrado en el sistema, se le hace corresponder un DNI y una Clave de
usuario (esta información se encuentra almacenada en la tabla alumnos). Esta tarea
ofrece al profesor, la posibilidad de eliminar la Clave de usuario de un alumno. De este
modo, el campo clave y email del registro asociado al alumno, se establecen a nulo.
Por consiguiente, el alumno debe volver a registrarse en el sistema, especificando su
nueva Clave de usuario.
1.2.1.1.45. ScriptGrupo (profesor)
Se encarga de procesar correctamente la información introducida en los formularios
de las siguientes tareas:
addgrupo: Añadir un nuevo grupo.
editGrupo: Editar un grupo existente.
addAlumnosGrupo: Añadir alumnos a un grupo, desde un fichero Excel o
manualmente.
1.2.1.1.46. CompartirPractica (profesor)
Lista en una tabla todas las asignaciones compartidas que posea el profesor
identificado en el sistema.
Figura 23: Asignaciones compartidas
Se realiza una consulta a la tabla usuarios_asignaciones con el identificador del usuario
identificado en el sistema. Para cada entrada resultante, se obtiene la información de
la asignación asociada y el nombre de la práctica, se realizan consultas a la tabla
practicas_grupos o conjuntos_grupos (dependiendo de si se está ante una asignación
práctica - grupo o conjunto - grupo). Con la información obtenida, se va rellenando la
tabla adecuadamente.
1.2.1.1.47. Practicas (profesor)
Muestra por pantalla una tabla con todas las prácticas que haya subido el profesor que
se encuentre identificado en el sistema.
1.2.1.1.48. AddPractica (profesor)
Permite añadir una nueva práctica, rellenando, para ello, el formulario
correspondiente.
La versión de la práctica no la puede seleccionar el profesor. La práctica se actualiza
con la versión del servidor que se encuentra en la tabla versiones de la base de datos.
1.2.1.1.49. EditPractica (profesor)
Permite editar una práctica creada previamente.
Se muestra el formulario correspondiente, relleno con la información de la práctica
existente en la base de datos, permitiendo al profesor modificar los campos que vea
oportunos.
1.2.1.1.50. ScriptPractica (profesor)
Se encarga de procesar correctamente la información introducida en los formularios
de las siguientes tareas:
addPractica: Crear una nueva práctica.
editPractica: Editar una práctica ya existente.
En ambos casos, la versión de la práctica es actualizada con la versión del servidor. Se
procede a leer la única fila que debe haber en la tabla versiones. Se comprueba que el
enunciado y el fichero de utilidades subido por el profesor sean del tipo especificado,
Pdf y Zip respectivamente. Para ello, se compara las últimas cuatro cifras del nombre
del fichero recibido con la extensión que deberían tener.
1.2.1.1.51. TestPractica (profesor)
Permite simular la entrega de un alumno.
Se muestra una página en la que aparece un espacio. En él, el supuesto alumno, debe
escribir la solución de la práctica. Al pulsar Enviar se evalúa la solución, mostrando la
nota obtenida.
1.2.1.1.52. AjaxTestPractica (profesor)
Permite evaluar la solución subida por el profesor, al simular la entrega de un alumno.
Contempla los siguientes aspectos:
Posibilidad de aplicar el filtro de sintaxis (el asociado a la práctica y no a la
asignación ya que no hay asignación alguna).
Comprobación de la existencia de palabras prohibidas en la solución enviada.
Distinción del tipo de prácticas (C, Matlab…).
Comprobación previa del estado de la conexión socket (conexión entre la pasarela
TCP y el servidor PHP).
Comunicación con Matlab, a través de la pasarela TCP: Esta es la manera con la
que se lanza las variables iniciales, el código del alumno y el evaluador.
1.2.1.1.53. ExportPractica (profesor) e importPractica (profesor)
La tarea exportPractica permite exportar una práctica en un archivo Zip al
ordenador local del cliente.
Almacena el enunciado de la práctica y el fichero de utilidades, si los posee, y un
archivo con extensión prac. Este archivo contiene la información introducida en el
formulario al crear la práctica.
Esta tarea enlaza con la tarea importPractica. Permite importar al servidor una
práctica que haya sido, previamente, exportada a través de exportPractica. De
esta manera, se evita la inserción a mano (rellenando el formulario oportuno) de la
práctica.
Al importar una práctica se comprueba que el fichero recibido tiene extensión Zip,
para ello, se compara las últimas cuatro cifras del nombre del fichero con la extensión
que debe tener. Se analiza si la versión de la práctica que se quiere importar es inferior
o igual a la versión del servidor destino. En caso afirmativo se procede con la
importación de la práctica, en caso contrario, no se importa y se muestra un mensaje
de error.
1.2.1.1.54. Conjuntos_ejerc (profesor)
Permite crear y editar conjuntos de ejercicios.
Figura 24: Crear - editar conjunto de ejercicios
1.2.1.1.55. Crear_conjunto (profesor)
Muestra un formulario a rellenar con los datos del nuevo conjunto que se quiere crear.
Figura 25: Formulario para creación de un nuevo conjunto
Se lista en una tabla todas las prácticas que posee el profesor identificado en el
sistema. El profesor selecciona las prácticas que formarán parte del conjunto. Si se
pulsa Grabar se procede a la creación del conjunto (se llama al método
script_crear_editar_conjunto), en caso contrario, si se pulsa Cancelar se
vuelve a la página anteriormente visitada.
1.2.1.1.56. Mostrar_pract_conjunto (profesor)
Permite listar en una tabla las prácticas que componen un determinado conjunto al
editarlo.
Figura 26: Editar las prácticas vinculadas a un conjunto
Se muestra todas las prácticas que posee el profesor identificado en el sistema,
seleccionando aquellas que pertenezcan al conjunto. El profesor puede establecer una
nueva selección de prácticas pertenecientes al conjunto, marcando y desmarcando las
prácticas que considere oportunas. Finalmente, puede hacer definitivo los cambios
efectuados pulsando Grabar (se llama al método
script_crear_editar_conjunto) o volver a la página anteriormente visitada
pulsando Cancelar.
1.2.1.1.57. AddconjuntoGrupo (profesor)
Permite crear una asignación de tipo conjunto - grupo en la página Editar
conjunto.
Figura 27: Crear nueva asignación conjunto - grupo
Muestra un formulario a rellenar con los datos de la nueva asignación que se quiere
crear. Se determina el subgrupo vinculado en la asignación. Al finalizar, se puede
pulsar Grabar y crear la asignación (se llama al método scriptConjuntoGrupo) o
pulsar Cancelar y volver a la página anteriormente visitada.
1.2.1.1.58. ScriptConjuntoGrupo (profesor)
Se encarga de procesar correctamente la información introducida en los formularios
de las siguientes tareas:
addConjuntoGrupo: Se formatea las fechas, se inserta la asignación en la
tabla conjuntos_grupos y se inserta nuevos registros en la tabla
usuarios_asignaciones con los DNIs de profesores autorizados (previamente se
comprueba que cada DNI introducido corresponde con un profesor registrado en
el sistema, tabla usuarios). Finalmente, se redirecciona a la tarea
conjuntos_ejerc.
editPracticas_conjuntosGrupos: Si se decide editar una asignación de
tipo conjunto - grupo. Se formatea las fechas y se actualiza el registro asociado
de la tabla conjuntos_grupos. Finalmente, se redirecciona a la tarea
practicasGrupos.
1.2.1.1.59. DeleteConjunto (profesor)
Permite borrar un determinado conjunto de ejercicios.
Inicialmente, se comprueba que el conjunto que se desea eliminar no haya sido
asignado a ningún grupo. Si hay alguna asignación, se muestra un mensaje indicando
que se debe borrar antes las asignaciones.
1.2.1.1.60. Editar_conjunto (profesor)
Lista en una tabla todos los conjuntos de ejercicios que posee el profesor identificado
en el sistema.
Figura 28: Conjuntos de ejercicios que posee el profesor
En la columna OPCIONES, se permite al profesor borrar un conjunto y crear una nueva
asignación de un conjunto.
1.2.1.1.61. Script_crear_editar_conjunto (profesor)
Se encarga de procesar correctamente la información introducida en los formularios
de las siguientes tareas:
crear_conjunto: Se crea un nuevo conjunto. Se crea un nuevo registro en la
tabla conjuntos_ejercicios. Finalmente, se redirecciona a la tarea
conjuntos_ejerc.
mostrar_pract_conjunto: Se modifica un conjunto. Se actualiza la tabla
conjuntos_ejercicios. Finalmente, se redirecciona a la tarea
conjuntos_ejerc.
1.2.1.1.62. DeletePractica (profesor)
Permite borrar una práctica.
Para poder borrar la práctica, no puede haber asociación alguna con ningún grupo o
subgrupo (tabla practicas_grupos).
A la hora de borrar una práctica se borran también los ficheros vinculados a ella
(enunciado y fichero de utilidades).
1.2.1.1.63. Diagnostico (profesor)
Permite conocer el estado en el que se encuentra el servidor Matlab. El servidor puede
estar ocupado (realizando una evaluación), colgado (bucles infinitos en el código) o
corriendo (a la espera de recibir comandos) en el momento de realizar la consulta.
Inicialmente se muestra el mensaje Ejecutando diagnóstico, se manda a Matlab
(a través de la conexión socket) un comando simple (ver, por ejemplo), se configura
un tiempo de espera de lectura máximo igual a cinco segundos, se procede a la lectura
de la conexión.
Si la lectura es nula el servidor está ocupado o colgado, se muestra al profesor una
página en la que se le ofrecen dos alternativas:
Se le invita a que vuelva a intentarlo pasados cinco minutos.
Forzar un reinicio del servidor Matlab: Se llama al método
reiniciodiagnostico. Este método manda automáticamente un correo a
los administradores del sistema informándoles de la incidencia.
En caso contrario, el servidor está corriendo y se notifica por pantalla al profesor.
Figura 29: Estado del servidor Matlab corriendo
1.2.1.1.64. Reiniciodiagnostico (profesor)
Envía un correo electrónico a todos los administradores del sistema (acceso a tabla
usuarios). En el correo se informa de que un profesor ha solicitado el reinicio del
servidor, dejando tal decisión en manos del administrador.
1.2.1.1.65. Calificaciones (profesor)
Permite obtener las calificaciones de un grupo en una práctica/conjunto de ejercicios.
Se diferencian tres pasos:
Selección de un grupo: Se muestra una tabla con los diferentes grupos existentes,
permitiendo seleccionar el grupo concreto que se desea evaluar.
Selección de una asignación: Se muestra una tabla con las diferentes asignaciones
que posee el grupo seleccionado, permitiendo seleccionar la asignación que se
desea evaluar. Se observa dos tablas, la primera tabla corresponde a las
asignaciones vinculadas a prácticas individuales, la segunda lista las asignaciones
vinculadas a conjuntos de ejercicios. Si se selecciona un conjunto de ejercicios, se
llega a un paso intermedio en el que se ofrece la posibilidad de elegir las
prácticas del conjunto que se desean evaluar, permitiéndose seleccionar el
conjunto completo.
Evaluación: Se muestra una tabla con las notas de los diferentes alumnos y demás
información relevante sobre la evaluación. Se permite evaluar a todos los
alumnos o a algún alumno en concreto.
Para evaluar a un subgrupo, se procede de manera análoga. Tras seleccionar el grupo,
se elige la asignación asociada al subgrupo en cuestión. Finalmente, se muestra una
tabla con las notas de los alumnos pertenecientes al subgrupo, además de toda la
información y opciones antes mencionadas.
1.2.1.1.66. UltimasCalificacionesGrupo (profesor)
Permite obtener las últimas calificaciones del grupo que se seleccione en un fichero
Excel.
En dicho fichero, aparecerán las calificaciones obtenidas en todas las prácticas que
tenga asignadas el grupo seleccionado, cada una en una columna.
Dichas calificaciones corresponden a la última evaluación automatizada que se haya
realizado en cada práctica. Por ello, si se desea garantizar que la hoja de cálculo esté
actualizada, es preciso entrar previamente en cada una de las asignaciones y lanzar
una evaluación.
1.2.1.1.67. VerEntrega (profesor) y scriptEditarEntrega (profesor)
Estas tareas permiten al profesor ver y editar la solución entregada por un alumno en
una práctica concreta y modificar la solución propuesta.
Ofrecen la posibilidad de realizar comentarios o anotaciones. El profesor puede
especificar una nota, independiente de la que ofrece el evaluador. Finalmente, todas
las modificaciones realizadas, deben ser almacenadas correctamente en la base de
datos.
1.2.1.1.68. Evalua (profesor) y evaluaranking (profesor)
La tarea evalua permite evaluar a un alumno concreto en una práctica determinada
(paso tres de la tarea calificaciones). En el caso de evaluaranking, se
evalúa a todo un grupo.
El profesor puede seleccionar, al crear o editar una práctica, el modo en que se desea
que se lance una evaluación de un grupo completo. Si se selecciona lanzar la
evaluación de manera normal, se evaluará a cada alumno individualmente
obteniéndose la nota de cada uno. Al seleccionar lanzar la evaluación en modo
ranking, se realiza el mismo proceso que antes, obteniéndose el valor de un
determinado parámetro llamado rendimiento para cada alumno. Este parámetro
determinará la nota definitiva que tendrá cada alumno. El evaluador, en este último
caso, no proporciona la nota sino un parámetro arbitrario, por ejemplo, el tiempo de
subida en un sistema de control. La nota de un alumno se calcula teniendo en cuenta
el valor del parámetro obtenido por él y por todos los restantes alumnos. El
procedimiento es el siguiente:
Se ordenan de mayor a menor los rendimientos obtenidos por los alumnos en un
vector.
El profesor fija en el evaluador de la práctica la nota máxima y la nota mínima que
desea que tengan los alumnos.
Se calcula el número de alumnos efectivos: Número de alumnos que han realizado
entrega, con rendimientos positivos y cuyos rendimientos sólo aparezcan una
vez.
Se calcula el factor para el cálculo de las notas: El factor es el resultado de restar
la nota máxima con la nota mínima y el resultado, dividirlo entre el número de
alumnos efectivos.
Se calculan las notas asociadas a cada entrega: Se recorre el vector, estableciendo
para cada posición del mismo una nota. A la primera posición, al ser el
rendimiento más alto, se le asocia la nota mínima, a la segunda posición la nota
mínima más el factor, a la tercera posición la nota mínima más dos veces el
factor y así sucesivamente. Rendimientos iguales implican notas iguales.
Rendimiento negativo implica nota igual a cero.
Si se solicita evaluar a un alumno concreto en una práctica configurada en modo
ranking se rechazará la petición.
Las prácticas pueden ser de tipo C o Matlab. Si se va a lanzar la evaluación de prácticas
tipo Matlab, es necesario comprobar inicialmente el estado de la conexión socket
(conexión entre el servidor PHP y la pasarela TCP de comunicación con Matlab).
Si la práctica posee fichero de utilidades, se descomprime en la carpeta temporal.
En ambas tareas, se utiliza los métodos evaluaEntregaMatlab (lleva a cabo la
evaluación de prácticas tipo Matlab) y evaluaEntregaC (para prácticas de tipo C),
pertenecientes a la clase Evaluacion. Métodos importantes, que se tratan en la
sección en la que se aborda el fichero evaluacion.php.
1.2.1.1.69. Historial (alumno)
Muestra una tabla con los resultados obtenidos en cada una de las prácticas que tenga
asignado el alumno (por ejemplo: Nota obtenida, anotaciones del profesor...).
En una asignación, el profesor puede habilitar un filtro IP, especificando la dirección IP
inicial y final. Se evita que el alumno pueda acceder a su historial desde cualquier
ordenador. En las asignaciones que tengan activadas el filtro IP se comprueba
inicialmente si la dirección IP del alumno está dentro del rango especificado. Si no está
dentro del rango, en la tabla historial no aparecerá dicha asignación.
El profesor puede cambiar el estado de una asignación según sus necesidades.
Solamente aparecerán las asignaciones cuyo estado sea activo.
Las asignaciones visibles se listan en dos tablas. Una tabla para prácticas activas y otra
para prácticas antiguas. Se compara la fecha y hora actual con la fecha y hora final
especificada en cada asignación. En las prácticas activas, se permite al alumno enviar
sus nuevas soluciones. En las antiguas no se permite al alumno enviar nuevas
soluciones, solamente se permite ver su último envío si el profesor ha configurado la
asignación para tal efecto.
La nota de cada asignación, puede elegir el profesor mostrarla o no configurando
adecuadamente la asignación. Análogamente ocurre con la nota del profesor y los
comentarios del evaluador.
1.2.1.1.70. EnviarPractica (alumno)
Permite al alumno enviar la solución de una práctica concreta.
Para poder realizar correctamente el envío, es necesario que se esté dentro del plazo
de entrega, determinado por la fecha final retardada.
Muestra el último envío realizado por el alumno si el profesor así lo ha querido al
configurar la asignación, en caso contrario, se muestra la plantilla de la práctica. Si no
se ha entregado nada aún y la práctica posee una plantilla, se muestra la plantilla a
rellenar por el alumno.
Se permite resetear (JavaScript) la solución escrita por el alumno, mostrando la
plantilla de la práctica.
Se permite al alumno subir un fichero adjunto si la práctica lo permite. Si el alumno ha
subido con anterioridad un fichero adjunto se le brinda la posibilidad de descargárselo.
1.2.1.1.71. ConsultaPractica (alumno)
Permite consultar la solución a una práctica enviada por un alumno. Esta tarea está
disponible para las asignaciones cuyo plazo de entrega haya finalizado.
Para que se muestre la solución, el profesor debe haber habilitado los envíos pasados
en la asignación.
1.2.1.1.72. ScriptEnviarPractica (alumno)
Permite procesar adecuadamente la solución enviada por el alumno en la base de
datos.
Se contemplan los filtros y demás medidas que estén activadas. Como ejemplo, se
puede citar el filtro de sintaxis. Este filtro, analiza si hay algún error de sintaxis en la
solución propuesta por el alumno. Se apoya para ello, en la función de Matlab Mlint. Si
hay algún error, no se sube la solución y se muestra un error por pantalla. Si el
profesor ha habilitado el filtro IP, se comprueba que la dirección IP desde donde envía
la solución el alumno esté dentro del rango especificado.
El filtro de sintaxis aparece por un lado vinculado a una práctica y por otro lado
vinculado a una asignación. Si el filtro de sintaxis de la asignación está desactivado, no
se ejecuta dicho filtro, en caso contrario, se analiza el filtro de sintaxis de la práctica y
si está activado se ejecuta el filtro. Ejecutar el filtro en prácticas tipo Matlab conlleva
ejecutar la tarea comprobarSintaxisFiltrado, la cual se apoya en la función
Mlint. Debido a que Mlint es muy sensible en la detección de errores, el profesor
puede especificar los errores exentos de Mlint que necesite en la práctica. En prácticas
tipo C conlleva ejecutar la tarea comprobarCompilacion, la cual compila la
solución del alumno analizando si hay algún error.
A la hora de subir el fichero adjunto, se comprueba que es un fichero Zip.
Al subir una entrega al servidor, se fijan a nulo la nota, los comentarios del evaluador,
los comentarios del profesor, la nota del profesor y los comentarios del evaluador
destinados al profesor ya que están asociados a una entrega o evaluación pasada.
1.2.1.1.73. Deleteadjuntos (alumno)
Permite borrar un fichero adjunto existente en el servidor en el momento de realizar
un alumno una entrega.
Se apoya en el script deleteadjuntos.js. Script en JavaScript que permite paso de
parámetros hacia la tarea y ejecutarla refrescando la página mostrada. Muestra
inicialmente una ventana de confirmación.
1.2.1.2. Otros métodos auxiliares
La clase System alberga además otros métodos auxiliares:
getVars: Almacena en un vector de la clase, vars, todas las variables de tipo
Get y Post.
debugArray: Imprime por pantalla el contenido de un vector con las etiquetas
<pre>.
redirect: Permite redireccionar una página, mostrando por pantalla el
mensaje almacenado en la variable de sesión $_SESSION["message"].
getResume: Devuelve un resumen de una cadena de texto. Si no se especifica la
extensión la acorta a cincuenta caracteres.
formatDate: Convierte una fecha obtenida de la base de datos de la forma
AAAA-MM-DD en DD-MM-AAAA.
sendFile: Envía un fichero por el navegador. Por defecto, no se borra el fichero
una vez enviado.
searchDniStart: Recibe el contenido del fichero Excel en un vector. Devuelve
un vector, indicando en qué fila y en qué columna aparece la cabecera de
comienzo.
1.2.2. Database.php
Este script alberga a la clase Database. Permite realizar una conexión al servidor
MySQL, seleccionando la base de datos adecuada.
La información necesaria para llevar a cabo la conexión, se obtiene a través de
llamadas al método get de la clase Config. Se activa el soporte para UTF,
concretamente, se configura con codificación moderna UTF-8.
El proceso de conexión con la base de datos tiene lugar al crear el objeto. En la función
constructora, se llama al método connect encargado de realizar todo el proceso de
conexión.
Si se hace una segunda llamada a mysql_connect() con los mismos argumentos,
se abrirá nuevo enlace, ya que en la llamada el parámetro new_link se configura a
true.
Figura 30: Método connect: Proceso de conexión con la base de datos
Esta clase presenta otros métodos que no son llamados desde la función constructora
sino desde otras clases:
connected: Este método devuelve true si está activa la conexión con el
servidor y false en caso contrario. Si la conexión ha caído, una reconexión
automática es intentada. Se utiliza para ello, la función mysql_ping. Esta
función puede ser usada por scripts que permanecen pasivos durante largos
espacios de tiempo. De manera que se chequearía si el servidor ha cerrado la
conexión, reconectándose de ser necesario.
query: Realiza una consulta de MySQL. La consulta puede ser para extraer,
insertar, borrar información...
Function connect
Sí
Se abre conexión
servidor MySQL
¿Existe error?
No
Selección base de datos
¿Existe error?
No
Activación soporte
UTF-8
Return true
Return
false
Sí
Fin
Figura 31: Método query: Consulta MySQL
getError: Devuelve el valor de la variable errorMsg. La variable errorMsg
almacena el posible error producido durante el proceso de conexión en el
método connect o al realizar la consulta MySQL en el método query. Por
ejemplo, no se ha podido establecer la conexión con el servidor MySQL.
insert: Este método inserta un vector en la base de datos.
Function query
Sí
Se realiza consulta
MySQL
¿Existe error?
No
¿Consulta
extraer datos?
Return datos Return true
Sí
No Se muestra error por
pantalla
Return false
Fin
Figura 32: Método insert: Inserción vector en la base de datos
update: Actualiza un registro determinado por su keyname. El diagrama de
flujo es muy parecido al del método insert, teniendo en cuenta que, en este
caso, la consulta es de tipo UPDATE.
hasQuoted: Analiza la variable que se le pasa en la llamada, determinando si
presenta comillas o no (por ejemplo: 'asdfs'). Devuelve true en caso de
encontrar comillas y false en caso contrario.
1.2.3. Config.php - Configuración del sistema
Este script alberga a la clase Config. A través de Index.php se crea un objeto de esta
clase. En él, se almacena información referente a la configuración del sistema.
Esta información de configuración, es leída del fichero configuration.php, dentro de la
carpeta configuration.
El objeto alberga los siguientes miembros:
system: Puntero al objeto application de la clase System, creado en
index.php. El objetivo, es poder acceder a los métodos de application y de
otras clases (gracias a variables de application que actúan a modo de
puntero) desde el objeto de la clase Config.
version: Almacena la versión del servidor.
Function insert
Se configura consulta
tipo insertar un vector
Se representa
adecuadamente los datos
Se formula la consulta
Return true/false
Se realiza la consulta
Llamada a query
Fin
Variables relacionadas con la base de datos: host del servidor, database
(nombre de la base de datos), dbuser (nombre de usuario de la base de datos),
dbpassword (contraseña de usuario de la base de datos).
hashPrefix: Prefijo para las cadenas Hash.
language: Configura el idioma a utilizar en las páginas web mostradas al usuario
del sistema. Esta variable contiene el nombre del fichero php que se ejecuta para
establecer la correspondencia con las constantes del sistema. Los ficheros de
idiomas se encuentran en la carpeta languages.
expireTimeCookies: Duración de las Cookies.
cabeceraComienzo: Cabecera de comienzo del fichero Excel con los alumnos.
columnaDni y columnaNombre: Indica si aparece primero el ID (DNI) y luego
el nombre de los alumnos en el fichero Excel.
mysqldumpPath: Ruta a mysqldump para realizar las copias de seguridad de la
base de datos.
port: Puerto del Puente TCP con Matlab, para la evaluación de los alumnos.
Esta clase comprende los métodos siguientes:
leeConfig: Almacena en las variables del objeto correspondientes los valores
entresacados de la cadena devuelta con leeFichero.
leeFichero: Devuelve una cadena resultado de la lectura del fichero que se le
pase en la llamada (configuration.php).
get: Devuelve el valor de una variable del objeto, aquella que se le pase en la
llamada (por ejemplo dbuser). Es utilizada, por ejemplo, en las clases System
o Database.
1.2.4. Alumno.php
Este script alberga a la clase Alumno. Permite obtener información referente a un
alumno (por ejemplo el DNI) y realizar operaciones con los alumnos, por ejemplo:
Comprobar con qué grupo está asociado un alumno.
Insertar un alumno en la tabla alumnos.
Saber si hay alguna entrega por parte de un alumno.
Por otra parte, realiza diversas operaciones sobre los grupos, por ejemplo:
Determinar subgrupos pertenecientes a un determinado grupo.
Conocer el nombre de un grupo concreto.
Esta clase presenta una serie de métodos que son llamados desde otras clases:
get: Devuelve los datos de un alumno. La clase posee unas variables (por
ejemplo dni, nombre, email...) que contienen la información de un
determinado alumno, con el método get se obtiene el valor de alguna de estas
variables (la que se nombre en la llamada).
existeAlumno: Comprueba si existe algún alumno en la tabla alumnos con el
DNI que se le pasa en la llamada. En caso de existir únicamente un solo alumno
con ese DNI, guarda la información del alumno en las respectivas variables de la
clase devolviendo true, en caso contrario, devuelve false.
existeGrupoAlumno: Comprueba si un alumno está asociado a un grupo
determinado. Se realiza una consulta a la tabla grupos_alumnos, si se obtiene
únicamente una sola coincidencia se devuelve true, en caso contrario se
devuelve false.
insertaGrupoAlumno: Inserta un registro en la tabla grupos_alumnos.
Finalmente, devuelve true.
borraGrupoAlumno: Elimina un registro de la tabla grupos_alumnos.
Finalmente, devuelve true.
insertaAlumno: Inserta un registro en la tabla alumnos. Tras insertar el nuevo
registro, se obtiene el id asignado en la tabla al registro, para finalmente guardar
toda la información del nuevo alumno en las variables de la clase. Devuelve
true.
setData: Guarda la información de un alumno (información que se le pasa al
método en la llamada) en las respectivas variables de la clase.
resetPassword: Permite resetear la Clave de usuario de un alumno.
Concretamente, resetea la Clave de usuario y la dirección de correo electrónico
de un alumno concreto. Devuelve true.
getAlumno: Devuelve un vector con toda la información de un alumno. Además,
almacena toda la información del alumno en las variables de la clase.
isAlumnoEntrega: Devuelve true si un alumno ha realizado una entrega en
una determinada práctica asignada. En caso contrario, devuelve false.
areThereStudentsInGroup: Devuelve el número de alumnos que hay en un
grupo determinado, incluyendo los subgrupos que pueda haber.
getSubgrupos: Devuelve un vector con tantas posiciones como subgrupos
dentro del grupo hayan, en cada posición se almacena la cantidad de alumnos
que pertenecen al subgrupo dado por la posición en el vector. Por ejemplo, la
posición dos del vector almacena la cantidad de alumnos que pertenecen al
subgrupo dos.
getNombreGrupo: Devuelve el nombre del grupo especificado por su id.
1.2.5. User.php
Este script alberga a la clase User. Comprueba si una persona que intenta acceder al
sistema tiene una cuenta de usuario en la base de datos.
En caso afirmativo, se permite el acceso al sistema:
Se crean sus correspondientes variables de sesión.
Se analiza durante toda la conexión si el usuario tiene los permisos adecuados
para llevar a cabo las diferentes tareas que vaya solicitando.
Al salir del sistema, se lleva a cabo el cierre de sesión.
Esta clase presenta una serie de métodos que son llamados desde otras clases:
login: Comprueba si el DNI y la Clave de usuario pertenecen a algún usuario, ya
sea de la tabla usuarios (en la que se encuentra profesores y administradores) o
de la tabla alumnos (en la que se encuentra los alumnos). En caso afirmativo, se
registran las variables de sesión.
Figura 33: Método login: Protocolo de acceso al sistema a través de DNI y Clave
logout: Permite al usuario cerrar la sesión para abandonar el sistema. Se hace
una llamada al método destroy, elimina y destruye las variables de sesión. Se
eliminan las cookies.
Function login dni,clave,remember
Se realizan consultas a las
tablas alumnos y usuarios
¿Existe un único
usuario?
Sí
Se extrae los datos del
usuario
(nombre,dni,categoría...)
¿remember on and
categoría=profesor/administrador?
Sí
Se encripta la clave y
categoría
Se crean las cookies dni,
clave y categoría
Se registran las variables de sesión
Llamada a register con los datos
Return true
No
No
Fin Return false
start: Se inicia una nueva sesión y se determinan las reglas por las que el
contenido de la página puede ser guardado en la caché local del cliente. Este
método, permite acceder al sistema saltándose el proceso de login. Se distinguen
dos situaciones: El usuario ha accedido previamente al sistema marcando
recuérdame (siempre que sea profesor o administrador), se han creado las
cookies oportunas, el usuario sale del sistema sin cerrar sesión y decide
nuevamente entrar en él o bien el usuario se encuentra en el sistema saltando
de tarea en tarea ($_SESSION["logged"] = 1).
Figura 34: Método start: Protocolo de acceso al sistema a través de cookies
register: Registra las variables de sesión. Entre las variables de sesión, destaca
la variable $_SESSION["logged"], indica si el usuario ha iniciado sesión o
no.
Function start
Configuración caché local cliente
Se inicia una nueva sesión
¿Existen cookies and
usuario no logueado?
Sí
¿Las cookies del usuario pertenecen a
la categoría profesor/administrador?
Sí Categoría=profesor/administrador
Consulta a tabla usuarios con
$_COOKIE['dni']
Se encripta la clave obtenida
Se compara con $_COOKIE['clave']
Return true
No
No
¿Coinciden ?
Sí
No
Se registran variables sesión
Llamada a register
Fin
createHash: Genera un número aleatorio. Se utiliza para encriptar la
información.
isLogged: Comprueba si se ha iniciado sesión en el sistema. En caso afirmativo,
devuelve true.
isAdmin: Devuelve true si el usuario que ha iniciado sesión es administrador y
false en caso contrario.
getCategory: Devuelve el valor de la variable de sesión que almacena la
categoría del usuario (profesor, administrador o alumno).
isMessage, deleteMessage, getMessage: Métodos para gestionar la
variable de sesión message (Comprueba si hay mensaje, borra mensaje y
recupera el mensaje).
isAllowed: Comprueba si un usuario que ha iniciado sesión tiene los permisos
requeridos para acceder a una tarea concreta. Devuelve true en caso de que
tenga los permisos y false en caso contrario.
getUserId: Devuelve el id (campo id de las tablas alumnos o usuarios) del
usuario que ha iniciado sesión en el sistema. Si se le pasa un DNI en la llamada al
método, devuelve el id del usuario asociado a dicho DNI.
1.2.6. Menu.php
Este script alberga a la clase Menu. Configura el menú apropiado para cada usuario del
sistema, en función de las tareas que pueda llevar a cabo.
En esta clase se encuentran los siguientes métodos:
createMenus: Construye el menú global del sistema. Establece, utilizando el
método addElement, todas las posibles entradas que puede tener el menú.
Cualquier link de llamada a una tarea que aparezca en una página debe estar
definido en el vector menu de la clase a través de este método. Fija la tarea,
nombre de la entrada, icono, categoría (indica qué usuarios tienen permiso para
la tarea en cuestión y por tanto con qué usuarios aparecerá esta entrada en su
menú), visibilidad de la entrada e identificador de la entrada desde la que se
despliega el submenú (parent).
addElement: Añade un elemento al vector menu. Devuelve el identificador
asignado a ese elemento. El identificador es la posición donde se almacena el
elemento en el vector menu.
getMenu: Devuelve un vector con todas las entradas de menú (vector menu),
establecidas en createMenus.
getPrimaryMenu: Devuelve el menú primario (sin submenús) del usuario.
getSecondaryMenu: Devuelve el menú secundario (submenú) de un elemento
del menú primario.
has_subMenu: Devuelve true si el elemento contiene un submenú.
is_subMenu: Devuelve true si el elemento es un submenú.
getParent: Devuelve el parent de un elemento.
getId: Devuelve el identificador de una tarea. En caso de no obtener
coincidencias, devuelve null.
1.2.7. Xtemplate.php – html.php – template.html – Representación de
la información por pantalla
El script html.php alberga a la clase Html, que hereda los métodos (relación padre-
hijo de clases) de la clase Xtemplate dentro del script xtemplate.php. Estas clases se
complementan para poder rellenar la plantilla que siempre se muestra por pantalla:
template.html.
En la función constructora de la clase Xtemplate se llama al método maketree, el
cual recorre el fichero template.html y va almacenando en el vector blocks los
diferentes bloques y subbloques (bloques anidados en el interior de un bloque) que
encuentra (caracterizados por empezar por <!-- BEGIN y acabar por <!-- END).
Por otro lado, se establece el orden que tienen los diferentes bloques en la plantilla. Es
en el vector block_parse_order, donde se almacena el orden de aparición de los
diferentes bloques que componen la plantilla. Atendiendo a la disposición que
presentan los bloques en template.html, en la primera posición del vector se
encontraría main (indicando que es el bloque main el primero en aparecer), en la
segunda posición main.javascript y así sucesivamente. El vector sub_blocks
permite llevar un control sobre los subbloques contenidos en cada bloque. Atendiendo
nuevamente a template.html, el vector sub_blocks albergaría, por ejemplo, en la
posición main un vector con main.javascript y main.styles.
El método _store_filevar_parents permite almacenar en el vector
filevar_parent los ficheros que hay que sustituir en los diferentes bloques. Al
añadir ficheros a la plantilla, los vectores anteriores se actualizan, ya que puede haber
bloques nuevos a tener en cuenta, estableciendo un orden nuevo.
En la clase Xtemplate, se encuentra el vector blocks (almacena en cada posición
los bloques a los que no se les ha dado todavía el formato adecuado para ser
representado, “bloques no parseados”), el vector preparsed_blocks (almacena
en cada posición bloques en los que se han incluido archivos) y el vector
parsed_blocks (almacena en cada posición “bloques ya parseados”).
El método más relevante de la clase Xtemplate es parse, el cual permite “parsear
bloques” (dar a los bloques un formato concreto y agruparlos convenientemente para
que el servidor XHTML pueda interpretarlos correctamente). En la llamada, se le pasa
el bloque que va a ser “parseado”. Busca el bloque en preparsed_blocks y si no
lo encuentra (no se ha incluido un fichero en el bloque previamente), en blocks
(contempla todos los bloques que tiene la plantilla). Tras ello, lo “parsea” incluyendo
en la posición adecuada (en el bloque aparecen sentencias del tipo
_BLOCK_main.javascript que indican la posición donde se debe incluir el
subbloque main.javascript) posibles subbloques ya “parseados”, para
finalmente, almacenar el bloque ya tratado en parsed_blocks.
Si no encuentra el bloque en los vectores citados, se mata el proceso (hay una
incongruencia).
El objetivo final, es llegar a tener en un único bloque (main) toda la plantilla
correctamente “parseada”, para finalmente, llamar al método out. Este método,
obtiene todo el texto del bloque main y lo muestra por pantalla mediante la función
echo.
Destacar el método insert_loop, el cual llama a los métodos assign y parse:
assign: Asigna valor a una variable de template.html para posteriormente
“parsear” el bloque.
scan_globals permite almacenar el valor de las variables globales en una variable
local. Utiliza el método assign para asignar a la variable PHP de template.html el
valor del vector local. A través de PHP._SESSION se accede a las variables de sesión
(por ejemplo, con PHP._SESSION.nombre se accede a la variable de sesión
nombre).
La clase Html alberga al método out. El cual se encarga de rellenar la plantilla para
finalmente, representar por pantalla la página que es adecuada en cada momento, con
el estilo, menú, información y contenidos correspondientes.
Figura 35: Método out: Representación por pantalla de la plantilla
Function out
Se escanea las variables
globales
Sí
No Se asigna valor a
JAVASCRIPTCODE
(código javascript)
Posibilidad de mostrar la cola de
mensajes de depuración
Se asigna valor a WEBSITE_TITLE
(título del sitio web)
¿Hay código Javascript
que incluir ?
Se parsea el fichero de jQuery
(librería javascript a incluir en todas las páginas)
Se parsea los estilos generales del portal
Se asigna valor a MENU
(menú a mostrar incluyendo posible submenú)
Se parsea el perfil de usuario (profesor, alumno o administrador)
Si hay mensaje se parsea
(Se encuentra en $_SESSION["message"])
Se asigna valor a VERSIÓN
(versión del servidor)
Se parsea el main
(Finalmente se tiene toda la plantilla parseada)
Se muestra por pantalla la plantilla parseada
Fin
En esta clase se encuentran también los siguientes métodos:
addScript: Permite añadir en la plantilla un nuevo script de cualquier tipo, por
ejemplo, JavaScript. Los nombres de los diferentes scripts se van almacenando
en el vector de la clase scripts. Este método es el preferido a la hora de
añadir a las páginas utilidades en JavaScript (por ejemplo validation.js).
addJavascript: Permite añadir un código JavaScript concreto en la plantilla.
Se añade el código en la variable de la clase javascript.
assign_file: Se llama al método assign_file de la clase Xtemplate, el
cual llama a su vez al método _assign_file_sub. Permite sustituir un
fichero (por ejemplo bienvenido.html) en los bloques correspondientes.
El vector filevar_parent almacena los nombres de los bloques en los que hay que
realizar la sustitución (por ejemplo, si se quiere sustituir bienvenido.html en FILE
{CONTENT}, en la posición CONTENT del vector se tendrá un vector con los nombres
de los bloques en los que hay que realizar la sustitución). Una vez realizada la
sustitución, el bloque es almacenado en el vector preparsed_blocks.
error: Muestra una página de error. Para ello, se debe incluir el fichero de estilo
para errores y asignar a ERROR el mensaje que debe aparecer por pantalla.
renderDebug: Permite mostrar por pantalla la cola de mensajes de depuración.
A continuación, se va a analizar la estructura de la plantilla template.html:
Declaración del tipo de documento XHTML: DOCTYPE declara la versión del
lenguaje, interpretación y localización del DTD (declaración del tipo de
documento) relacionado.
Espacio de nombres que va a ser utilizado en el documento: El enlace al espacio
de nombres se utiliza sólo como identificador, en esa dirección no hay ninguna
definición sobre el espacio de nombres que pueda entender el navegador
(xmlns="http://www.w3.org/1999/xhtml").
head: Establece el nombre del sitio web, carga el código JavaScript necesario y
las hojas de estilo oportunas. Por otro lado, especifica que la codificación a
utilizar es UTF-8.
body: Se estructura del siguiente modo: cabecera_derecha (muestra nombre del
usuario, Cerrar sesión...), cabecera_izquierda (Servidor de Docencia),
menú lateral izquierdo (menú con las diferentes entradas), a la derecha del menú
aparecen posibles mensajes (a modo práctica actualizada
correctamente...), título de la zona central, fichero Html y se tiene la
posibilidad de incluir el botón de volver a la página anteriormente visitada. Por
último, en la parte inferior de la web se encuentra el footer (con información
referente a la versión, el departamento...).
Figura 36: Estructura template.html – body
1.2.8. Practica.php
Este script alberga a la clase Practica. Permite obtener toda la información
relevante de las prácticas existentes en el sistema (tipo, nombre, activación filtro de
sintaxis...), de las entregas realizadas por los alumnos y de las asociaciones práctica-
grupo y práctica-usuario.
En esta clase se encuentran los siguientes métodos:
isPractica: Permite averiguar si hay alguna práctica asociada a un grupo
concreto. Devuelve true si hay alguna práctica asociada (si el grupo presenta
subgrupos se analiza si hay alguna práctica asociada a algún subgrupo) y false
en caso contrario. Se realiza una consulta, a través del método query, a la tabla
practicas_grupos con el identificador de grupo.
getTipoPractica: Permite averiguar de qué tipo (práctica tipo Matlab, C ...)
es una práctica concreta. Se realiza una consulta, a través del método query, a
la tabla practicas con el identificador de la práctica. El método devuelve el tipo
de práctica.
getPracticas: Devuelve en un vector todas las prácticas pertenecientes a un
usuario determinado (en esta ocasión por usuario se entiende a un profesor). Si
en la llamada al método no se especifica el identificador de usuario, el método
toma el identificador correspondiente al usuario que tenga la sesión abierta. Se
realizan consultas a las tablas usuarios_practicas y practicas (a través del método
query). De la primera tabla se obtiene los identificadores de las prácticas y de la
segunda tabla se obtiene las prácticas asociadas a esos identificadores.
getPractica: Devuelve en un vector la información de una práctica
determinada. Se realiza una consulta, a través del método query, a la tabla
practicas con el identificador de la práctica (el identificador de la práctica se debe
pasar como argumento en la llamada al método).
getNombrePractica: Devuelve el nombre de la práctica asociada al
identificador de práctica que se le pase al método en la llamada. Se realiza una
consulta, a través del método query, a la tabla practicas con el identificador de
la práctica.
practicaEntregada: Permite averiguar si una práctica ha sido entregada por
parte de un alumno. Se realiza una consulta, a través del método query, a la
tabla entregas con el identificador de alumno y el identificador de práctica-grupo
(identifica unívocamente una asociación práctica-grupo que haya realizado algún
profesor). Estos parámetros se le pasan al método en la llamada. Devuelve true
si la práctica ha sido entregada y false en caso contrario.
isFiltroSintaxis: Permite averiguar si una práctica tiene habilitado el filtro
de sintaxis. Se realiza una consulta, a través del método query, a la tabla
practicas con el identificador de la práctica (este parámetro se le pasa al método
en la llamada). Devuelve uno si el filtro de sintaxis está habilitado y cero en caso
contrario.
getSolucionAlumno: Permite obtener la solución propuesta por un alumno
en una práctica concreta. Se realiza una consulta, a través del método query, a
la tabla entregas con el identificador de alumno y el identificador de práctica-
grupo. Devuelve la solución propuesta por el alumno o null en caso de que el
alumno no haya enviado la solución de la práctica.
descomprimePractica: Permite descomprimir el fichero de utilidades de una
práctica en el directorio temporal. Se apoya en la clase ZipArchive (esta clase
pertenece a la librería interna del servidor PHP) para poder tratar el fichero
comprimido. Si no se puede abrir el fichero de utilidades, se muestra el mensaje
ERROR ZIP por pantalla y se devuelve true. En el caso de que la práctica no
posea fichero de utilidades, se devuelve false y true si la práctica posee
fichero y se ha descomprimido correctamente en el directorio temporal.
1.2.9. Message.php
Este script alberga a la clase Message. Permite añadir mensajes de depuración, útiles
para el programador a la hora de depurar el servidor.
En esta clase se encuentran los siguientes métodos:
addMessage: Añade un mensaje (se le pasa al método en la llamada) al vector
messages (messages es un vector definido en la clase). El mensaje se añade
en una nueva posición del vector.
addMessageArray: Añade un mensaje de tipo vector a messages. En la
llamada, se le pasa al método un vector de datos y el título (es opcional, si no se
le pasa nada el mensaje no tendrá título) que va a tener el mensaje. El método
añade en una nueva posición del vector messages un mensaje del tipo: vector
título: nombre posición1=valor posicion1, nombre posición2=valor posición 2...
Donde nombre posición1 se refiere al nombre que tenga la posición primera del
vector de datos y valor posición1 al valor almacenado en esa posición.
getMessages: Devuelve el vector messages.
1.2.10. ZipFolder.php
Este script alberga a la clase ZipFolder. Permite comprimir una carpeta. Al
comprimir la carpeta se pueden obviar archivos con una determinada extensión (por
ejemplo archivos con extensión svn). Se comprime todo lo que haya dentro de la
carpeta (ficheros, carpetas...). La compresión se realiza al crear un objeto de esta clase,
al crear el objeto se le pasa a la función constructora el nombre que se le quiere dar a
la carpeta comprimida (por ejemplo practicas.zip), el directorio donde se encuentra los
archivos que se quieren comprimir (por ejemplo si se quiere comprimir la carpeta
practicas, el directorio sería practicas/) y la extensión de los ficheros que se quieren
obviar en la compresión (por ejemplo .svn). Finalmente, dentro de la carpeta que se
quiere comprimir aparecerá la carpeta comprimida con el nombre que se haya elegido.
1.2.11. Evaluacion.php
Alberga a la clase Evaluacion. Permite evaluar la entrega de un alumno ejecutando
los filtros oportunos (por ejemplo: Filtro de sintaxis). La entrega puede ser de cualquier
tipo soportado por el sistema (Matlab, C). Configura, establece y cierra la conexión
socket, conexión entre el servidor PHP y el servidor TCP de comunicación con Matlab.
En el caso de evaluar una entrega tipo C, la conexión socket no es necesaria.
Al crearse un objeto de esta clase, la función construct permite establecer la
comunicación entre los servidores PHP y TCP mediante la creación y conexión del
socket.
Figura 37: Función construct: Establecimiento conexión socket
La función destruct permite cerrar el recurso socket. La función destruct se
encarga de realizar las tareas que se necesita ejecutar cuando el objeto deja de existir.
Cuando un objeto ya no está referenciado por ninguna variable, deja de tener sentido
que esté almacenado en la memoria, por tanto, el objeto se debe destruir para liberar
su espacio. En el momento de su destrucción se llama a la función destruct.
En esta clase se encuentran los siguientes métodos:
getVariable: Devuelve el valor de una variable del Workspace de Matlab. El
nombre de la variable se le pasa al método en la llamada.
enviaCadena: Envía una cadena (la cadena se le pasa al método en la llamada)
al puente TCP para comunicarse con Matlab. Para enviar la cadena al puente TCP
se utiliza la instrucción socket_write indicándose el tamaño de la cadena que se
envía. Para leer la contestación del puente TCP se utiliza la instrucción
socket_read, en la que se especifica el tamaño máximo de la lectura. Devuelve la
lectura realizada del puente TCP.
No
Sí
Sí
No
Function construct system
Se crea la conexión
socket
Se conecta el socket
¿Error?
No se muestra por
pantalla el error
¿Error?
No se muestra por
pantalla el error Timeout de 3 segundos
Fin
evaluaEntregaMatlab: Evalúa una entrega de tipo Matlab. La casilla filtro de
sintaxis no puede estar activa en las prácticas en las que se pide al alumno que
cree una función en Matlab, debido a que Mlint detecta que el nombre del
archivo temporal en el que se guarda la función no coincide con el propio
nombre de la función, como consecuencia, se genera error.
Figura 38: Método evaluaEntregaMatlab: Evalúa una entrega de tipo Matlab (I)
Function evaluaEntregaMatlab identrega,idpractica,idasignacion,practica_conjunto
Sí
¿Se puede abrir el fichero y
escribir en él la solución?
Se envía a Matlab el
nombre del fichero
(fichero_alumno)
Se muestra error por
pantalla
Se obtiene información de práctica, alumno y
entrega (distinción practica-grupo conjunto-grupo)
Se establece ruta de trabajo de Matlab
(carpeta temporal)
Se limpia el Workspace de Matlab
(inicialización variables nota, comentarios)
Se almacena en nombre_fichero_alumno el nombre
del fichero que contendrá la solución del alumno
Se almacena en envio_alumno la ruta completa al
fichero nombre_fichero_alumno
Se obtiene la solución propuesta por el alumno
No
Se envía a Matlab el dni del alumno, fecha y hora de
entrega, identrega, idpractica, directorio Workspace
Se actualiza la nota a –5
Se ejecutan las variables iniciales
Figura 39: Método evaluaEntregaMatlab: Evalúa una entrega de tipo Matlab (II)
Se comprueba la sintaxis (errores exentos de Mlint)
Si hay error: error_sintaxis=1
¿Está activado el filtro de
sintaxis?(asignación y práctica)
No Sí
Sí
¿Inhibir código del alumno?
No
Se ejecuta en Matlab la solución alumno
Si hay error: error_sintaxis=1
Se almacena en nombre_fichero_profesor el nombre
del fichero que contendrá el evaluador de la práctica
Se almacena en fichero_profesor la ruta completa al
fichero nombre_fichero_profesor
Se ejecuta en Matlab el
evaluador
Se muestra error por
pantalla
Se obtiene el evaluador de la práctica
¿Se puede abrir el fichero y
escribir en él el evaluador?
Sí No
Se elimina el fichero nombre_fichero_profesor
Si hay error: error_sintaxis=1
¿Existe algún error?
(¿error_sintaxis=1?)
No Sí
Figura 40: Método evaluaEntregaMatlab: Evalúa una entrega de tipo Matlab (III)
comprobarPalabrasProhibidas: Comprueba si en la solución propuesta
por el alumno hay alguna palabra prohibida. Las palabras prohibidas se
encuentran en una lista que confecciona el profesor al crear la práctica. Devuelve
null si no existe ninguna palabra prohibida en la solución, en caso contrario,
devuelve la lista de palabras prohibidas encontradas en formato string. Si no hay
lista de palabras prohibidas en la práctica, se devuelve null.
comprobarSintaxis: Analiza si existe algún fallo de sintaxis en la solución
propuesta por el alumno. La solución se le pasa al método en la llamada.
Devuelve true si está todo correcto o los errores de sintaxis en caso contrario.
Para realizar la comprobación, se utiliza la función Mlint de Matlab. Mlint es más
sensible en la detección de fallos que la propia ejecución en Matlab.
comprobarSintaxisFiltrado: Aporta la misma funcionalidad que el
método comprobarSintaxis. Ofrece además, la posibilidad de omitir ciertos
errores que pueda mostrar Mlint. En la llamada se le pasa al método una cadena
de caracteres que determina los errores exentos de Mlint separados por espacios
en blanco. La función para Matlab llamada verifica es la responsable de llamar a
Mlint y determinar el número de errores que tiene la solución propuesta por el
alumno, exceptuando los errores que se quiera omitir. Devuelve true si no hay
más errores que los contemplados en la cadena de caracteres o todos los errores
de sintaxis en caso contrario.
Se actualiza la base de datos
Si es evaluación ranking se obtiene nota máx y mín
Se elimina el fichero nombre_fichero_alumno
Return true
Fin
Se recupera nota y
comentarios del
Workspace
Se actualiza nota a -5
comprobarCompilacion: Comprueba si existe errores a la hora de compilar
un determinado fichero C. El código del alumno se le pasa al método en la
llamada. Devuelve la lista de errores encontrados o null en caso contrario. Para
realizar la compilación, se utiliza el programa Dev-Cpp.
evaluaEntregaC: Evalúa una entrega de tipo C.
Figura 41: Método evaluaEntregaC: Evalúa una entrega de tipo C (I)
Function evaluaEntregaC
identrega,idpractica,practica_conjunto
Se obtiene información de práctica y entrega
(distinción práctica-grupo conjunto-grupo)
Inicialización nota=-5
Se almacena en solucionalumno y en inicioprofesor
la solución del alumno y las variables iniciales
Se almacena en envio_alumno el nombre del fichero
que contendrá las variables iniciales y la solución
del alumno
Se almacena en salida_alumno el nombre del
fichero que contendrá el .exe asociado a
envio_alumno
Se almacena en nota_alumno el nombre del fichero
que contendrá la nota del alumno
Sí
¿Se puede abrir el fichero
envio_alumno y escribir en él las
variables iniciales y la solución?
Se compila
envio_alumno
(Dev-Cpp)
Se muestra error por
pantalla
No
Se ejecuta el script ejecuta
(Equivalente al evaluador en Matlab)
Se recupera nota alumno (lectura fichero
nota_alumno) (detección fichero corrupto)
Figura 42: Método evaluaEntregaC: Evalúa una entrega de tipo C (II)
1.2.12. Procesaejerciciojava.php
Se encarga de recepcionar correctamente los datos enviados a través de la aplicación
Java, realizando las comprobaciones oportunas de autenticación. El objetivo final es
almacenar en la base de datos la nueva entrega realizada por el alumno.
Se ha desarrollado una aplicación java capaz de interactuar con el alumno de manera
amena y versátil. A través de esta aplicación, el alumno introduce diferentes
parámetros asociados al controlador diseñado para el control del sistema propuesto,
simula el comportamiento del sistema en bucle cerrado/abierto, obtiene datos
específicos del sistema resultante (tiempo de subida, sobreoscilación…) y por último la
aplicación permite el envío de los parámetros anteriores relevantes al servidor de
docencia con una petición HTTP. La petición HTTP tiene un formato específico y
conocido por el servidor. La aplicación está se ha implementado con la herramienta de
trabajo Ejs (Easy Java Simulations).
No
¿Nota alumno vacía?
Se pone comentarios
vacío
comentarios=Posible
bucle infinito,nota=0
Sí
Se actualiza la base de datos
Se borran ficheros: envio_alumno, salida_alumno,
nota_alumno
Return true
Fin
Figura 43: Aplicación Java: Pestaña de experimentación
Figura 44: Herramienta Ejs: Modelo del sistema
En el script procesaejerciciojava.php se diferencian varios pasos:
Definición e inclusión de constantes del sistema.
Inclusión de las clases del sistema.
Se crea un nuevo objeto de la clase System.
Se selecciona el lenguaje.
Se procede a recuperar datos que han sido enviados a través de la aplicación Java
(DNI del alumno, id de la práctica, id del grupo, password encriptado con md5,
número de parámetros y firma encriptada con md5).
Se recuperan los parámetros que han sido enviados a través de la aplicación Java
(el número de ellos viene determinado por el dato número de parámetros
recuperado en el paso anterior).
Antes de subir la entrega a la base de datos hay que realizar comprobaciones. Se
comprueba que la firma es correcta, para ello, se encripta la firma del paquete y
se compara con la recibida. Se calcula la firma sin encriptar del paquete,
compuesta por el DNI, password encriptado, id de la práctica, id del grupo,
número de parámetros y la lista de parámetros enviados. Posteriormente, se
encripta la firma calculada y se compara con la firma recibida. Si la firmas no
coinciden se manda a la aplicación un mensaje de error, en caso contrario, se
continua realizando comprobaciones. Se consulta en la tabla alumnos si existe un
alumno con DNI igual al recibido, se comprueba que su Clave no esté vacía
(significaría que el alumno no se ha registrado en el sistema), se encripta con
md5 la Clave obtenida de la base de datos y se compara con la recibida. Si alguna
comprobación falla se manda un mensaje de error, en caso contrario, se
continúa realizando más comprobaciones. Se procede a comprobar si el alumno
pertenece al grupo, se comprueba si existe asignación, si está activa y se mira si
la entrega está dentro del plazo. Si todas las comprobaciones son correctas se
procede a almacenar la entrega en la base de datos (se fija a NULL los campos
nota, comentarios del evaluador y comentarios del profesor para evitar
confusiones).
Figura 45: Forma de almacenar los parámetros recibidos de la aplicación Java
2. Instalación desde cero del servidor de docencia
Es posible una instalación paso a paso del servidor de docencia:
Se crean las tablas de la base de datos con todos sus respectivos campos e
información.
Creación de prácticas: Enunciados de las prácticas, ficheros adjuntos y de
utilidades.
Es decir, se permite traspasar el servidor con toda su información de una máquina a
otra.
El procedimiento a seguir para realizar una instalación desde cero del servidor es:
Eliminar el fichero configuration.php: Se encuentra en la carpeta configuration.
Acceder al sistema: bono.us.es/sdocencia/index.php
Una vez realizada la instalación: Es necesario cambiar el nombre del fichero
index.php de la carpeta de instalación (index_temporal.php), de esta forma, en
los sucesivos accesos al sistema no se lanzará nuevamente el proceso de
instalación.
La carpeta installation alberga el fichero index, la plantilla, páginas html, ficheros
javascript, hoja de estilos, imágenes y diferentes scripts en php necesarios para que se
pueda mostrar la interfaz de instalación e interactuar para especificar diferentes
aspectos que se irán pidiendo durante la instalación del servidor (nombre que se le
quiere dar a la base de datos, usuario y contraseña...).
Figura 46: Instalación I: Interfaz de bienvenida
Figura 47: Instalación II: Importar backup file
Figura 48: Instalación III: Configuración base de datos
Figura 49: Instalación IV: Directorio MysqlDump
Figura 50: Instalación V: Configuración administrador
Tras seleccionar el idioma, se muestra un resumen en el paso 7. Sólo resta pulsar el
botón comenzar para llevar a cabo la instalación.
3. Estructura de la Base de Datos
Al ver la sistemática de trabajo de alumnos y profesores en el sistema y siendo
consciente de la naturaleza de la información que manejan, es necesario establecer la
estructura interna de los datos de la aplicación, es decir, la estructura de la base de
datos.
Se presenta un diagrama de la estructura de la base de datos. En él, los nombres de las
tablas son genéricos e ilustrativos y no coinciden con los nombres finalmente
implementados.
Se distinguen dos partes fundamentales, cada una de ellas proceden de orígenes
independientes:
Tablas relacionadas con la matriculación de estudiantes, lista de grupos y
organización de los grupos: Por ejemplo, la tabla grupos_alumnos que indica a
qué grupo/subgrupo pertenece cada alumno y que se corresponde con la tabla
student_group_membership.
Tabla que contiene la información de los ejercicios prácticos: Tabla exercises que
se corresponde con la tabla practicas finalmente implementada en el sistema.
El primer conjunto de tablas almacena los nombres de los estudiantes, DNI y demás
información relacionada. Esta información proviene, en general, de la administración
de la Universidad. La información relacionada con los estudiantes es introducida en la
base de datos a través de un fichero Excel (el cual debe poseer una estructura concreta
de columnas y filas).
La información de la tabla exercises proviene de los profesores existentes en el
sistema, los cuales irán creando prácticas que se almacenarán en dicha tabla. Los
profesores a la hora de crear prácticas pueden prescindir de hacerlo manualmente y
hacerlo automáticamente gracias a las funciones de importar/exportar prácticas.
Figura 51: Diagrama estructura base de datos: Tablas, campos y relaciones entre tablas
En una base de datos relacional, las relaciones permiten evitar los datos redundantes.
Se observa en el diagrama relaciones uno a varios. En una relación uno a
varios, una fila de la tabla A puede corresponderse con muchas filas de la tabla B,
pero una fila de la tabla B sólo puede corresponderse con otra de la tabla A. Por
ejemplo, se analiza la relación entre las tablas group_exercise_assignements y
exercises. Se observa en la tabla group_exercise_assignements que aparece el
identificador de ejercicios de la tabla exercises, de manera que cuando se realice una
asignación práctica-grupo se creará una nueva fila en la tabla
group_exercise_assignements con el valor del identificador de la práctica y el valor del
identificador del grupo (ya que también se establece una relación entre las tablas
groups y group_exercise_assignements). Se verifica que la relación es uno a
varios con cada una de las tablas (exercises y groups). Esto es debido a que se
tendrá diferentes asignaciones con el mismo identificador de grupo (se quiere asignar
varias prácticas a un grupo concreto) pero cada asignación que se realice se
corresponderá con un único grupo, lo mismo se puede decir para las prácticas.
Se observa una relación de tipo uno a varios en línea discontinua entre las tablas
version_control y exercises. El porqué de la línea discontinua tiene su fundamento en
la abstracción de la información almacenada en la tabla version_control, es decir, la
información relativa a la versión no es especificada por el profesor a la hora de crear
una práctica. A la hora de crear o modificar una práctica es el sistema el que fija la
versión de la práctica, estableciéndola igual a su versión.
La información de cada conjunto de tablas proviene de orígenes diferentes, es decir,
nuevos ejercicios pueden ser introducidos sin la creación de un nuevo grupo de
estudiantes y viceversa. No obstante, es necesario que estos conjuntos de tablas estén
estrechamente relacionados. En este contexto cobra sentido la tabla
group_exercise_assignments (equivalente a la tabla practicas_grupos), en la cual se
establecen asociaciones entre prácticas y grupos durante un periodo de tiempo
específico (por ejemplo, un ejercicio o práctica creada previamente se asocia a un
grupo/subgrupo determinado). Durante este periodo de tiempo se almacenan las
entregas en la tabla submissions (equivalente a la tabla entregas), la cual contiene la
solución propuesta por cada alumno.
Se muestra a continuación un breve resumen del contenido de cada tabla,
especificando los nombres que realmente tienen las tablas en el sistema:
groups (grupos): Almacena la información de los diferentes grupos (nombre del
grupo, año, cantidad de subgrupos que posee, titulación...).
student_group_membership (grupos_alumnos): Relaciona a cada alumno con su
correspondiente grupo/subgrupo (identificador del grupo, identificador del
alumno y subgrupo al que pertenece el alumno).
submissions (entregas): Almacena las entregas realizadas por los alumnos en las
diferentes prácticas (identificador del alumno, identificador practicas_grupos,
estado de la práctica, solución propuesta por el alumno...).
students (alumnos): Almacena la información de los diferentes alumnos (DNI,
nombre, email y Clave).
exercises (practicas): Almacena la información de las diferentes prácticas creadas
por los profesores (nombre de la práctica, fecha, descripción, enunciado,
evaluador de la práctica, versión, filtros...).
user_exercises (usuarios_practicas): Indica quién ha creado cada práctica
(identificador de la práctica, identificador del usuario que ha creado la
práctica...).
users (usuarios): Almacena información referente a los profesores y
administradores del sistema (DNI, nombre, Clave, email...).
group_users (usuarios_grupos): Indica el profesor responsable de cada grupo
(identificador del profesor, identificador del grupo...).
version_control (versiones): Almacena información referente a las versiones del
sistema (versión, alias, fecha, campos extras que añade la versión...).
group_exercise_assignments (practicas_grupos): Almacena las asignaciones
prácticas-grupos (identificador de la práctica, identificador del grupo, subgrupo,
activada/desactivada...).
Actualmente la base de datos ha sufrido variaciones asociadas a adición de nuevos
campos en las tablas existentes y creación de nuevas tablas (conjuntos_ejercicios,
entregas_conjuntos, actividades, sesiones…) para poder afrontar el desarrollo que ha
ido sufriendo el servidor.
Figura 52: Tablas de la base de datos
4. Cómo extender la funcionalidad
Se plantea, a modo de ejemplo, el caso en el que un profesor quiera introducir en el
sistema prácticas que no sean de tipo Matlab ni de tipo C (por ejemplo prácticas de
C++) o simplemente añadir nuevas funcionalidades a un tipo de práctica ya existente
(por ejemplo añadir a las prácticas tipo Matlab la posibilidad de activar/desactivar un
nuevo filtro). Los dos casos mencionados implican nuevos campos y entradas en la
interfaz de añadir práctica.
La modificación de la interfaz conlleva el manejo de nueva información que se traduce
en la definición de nuevas variables y métodos que lleven a cabo las nuevas
funcionalidades que se ofrezcan en la interfaz.
La tabla practicas de la base de datos también debe sufrir cambios puesto que se va a
almacenar información nueva en ella, es por ello por lo que en dicha tabla existen
campos vacíos (campo1, campo2, campo3…), para prever la posible ampliación de la
funcionalidad de las prácticas, manteniendo siempre la misma tabla.
Lo que se comenta anteriormente es el caso genérico. Puede ocurrir que no sea
necesario modificar la interfaz y tan sólo sea necesario incluir nuevos métodos y
variables debido a la naturaleza y necesidades de la nueva práctica.
Se quiere introducir prácticas de tipo C++ y en la interfaz de creación tan sólo se desea
que el profesor pueda ocultar las palabras prohibidas y activar/desactivar el filtro de
sintaxis. Estas opciones ya se contemplan en la interfaz por lo que no habría que
modificarla (aunque habría que modificar el menú despegable Tipo para poder
contemplar prácticas de tipo C++). No obstante, puede que el método que realice la
comprobación de la sintaxis varíe y se tenga que crear un nuevo método para este tipo
de prácticas (no se puede comprobar la sintaxis a través de la función Mlint de
Matlab).
Se ve que el abanico de posibilidades es amplio a la hora de extender la funcionalidad
del sistema. Cada caso concreto requerirá una forma de actuar diferente (en los
párrafos anteriores se muestran dos posibles formas de actuar de acuerdo con los dos
casos expuestos).
4.1. Modificación de la interfaz – Modificación de la tabla practicas y versiones de la base de datos
La modificación de la interfaz conlleva la modificación de la tabla practicas. Por
ejemplo, si se quiere contemplar a la hora de crear una práctica de tipo C++ la
posibilidad de activar/desactivar un filtro de optimización (filtro que determina si la
solución propuesta por el alumno tiene demasiadas líneas de código, siendo una
solución no óptima), se debe introducir esta posibilidad en la interfaz. Sin embargo,
para que sea efectiva y se pueda ejecutar el método asociado en el momento de la
entrega, es necesario que esta información se almacene en un nuevo registro de la
base de datos.
Así pues, se debe habilitar un nuevo registro en la tabla practicas para contemplar la
nueva funcionalidad. Siguiendo con el ejemplo, se habilita, por ejemplo, el registro
denominado campo1 de la tabla para almacenar información referente al filtro de
optimización. La versión del servidor determinará las prácticas que puede soportar el
sistema, especificando los registros denominados campo que contempla el sistema.
Figura 53: Tabla practicas: Habilitación campo1
Al seleccionar la tabla practicas, phpMyAdmin muestra un menú en la parte superior e
inferior, se hace click en la entrada estructura del menú. Se muestra la estructura de la
tabla practicas (con los diferentes registros que componen la tabla y las propiedades
de cada registro: Tipo, cotejamiento...). Para habilitar el campo1 se modifica el
registro, configurando el valor adecuado que deben tomar sus propiedades. La
configuración variará dependiendo del tipo de información que se quiere almacenar en
el registro de la tabla. En el ejemplo propuesto sería de tipo binario ya que sólo puede
tomar el valor uno o cero, pero si, la información que va a almacenar es una cadena de
caracteres podría ser de tipo text. Para dudas relacionadas con el valor que deban
tomar las propiedades, phpMyAdmin dispone de un manual, además al poner el cursor
del ratón en las propiedades se despliega un texto informativo.
Figura 54: Tabla practicas: Habilitación campo1 – menú y propiedades
Siguiendo con el ejemplo, el tipo de dato que va a soportar el registro es binario,
longitud uno (al ser el dato binario sólo posee un dígito) y predeterminado a valor
cero. Las restantes propiedades están vacías excepto nulo que se encuentra
seleccionado (indicando que por defecto el campo va a estar a cero, ya que así se ha
elegido en predeterminado, si no se le especifica un valor).
Figura 55: Tabla practicas: Habilitación campo1 – configuración
No obstante, el procedimiento más recomendable a seguir, puesto que es el que
respeta realmente la filosofía de los registros llamados campos, es no realizar ningún
tipo de modificación. Es decir, estos registros están configurados para que sean de tipo
texto, de esta forma se consigue la mayor generalidad posible (pueden contener un
número binario o real codificado como una cadena de caracteres).
Cuando se procede a extender la funcionalidad del servidor, se debe actualizar la tabla
versiones, modificando la única fila existente en la tabla con las características de la
nueva versión (alias, fecha, comentarios...). De esta forma, se puede llevar un control,
sabiendo en todo momento la versión del servidor y los campos extras que se han
habilitado con respecto a la versión inicial (versión 1.0). Haciendo posible que los
métodos sepan en qué versión se encuentran actuando en consecuencia. Por tanto, al
crear/modificar una práctica el sistema determinará la versión. La versión es
almacenada en un registro de la nueva práctica creada.
Piénsese, por ejemplo, en varias versiones de prácticas tipo Matlab (se diferencian en
la adición de nuevos filtros), al importar una práctica, el sistema debe ver si la versión
de la práctica es superior a su versión. Si es superior no puede importarla ya que no
está preparado para poder manejarla correctamente.
En la interfaz que se muestra para crear una nueva práctica se mostrarán los filtros
correspondientes a la versión del servidor. Por ejemplo, se tienen dos versiones en las
prácticas tipo Matlab: La versión inicial y otra en la que se añade el filtro de
optimización antes mencionado, a la hora de crear una nueva práctica tipo Matlab en
servidores que manejan prácticas con filtro de optimización (versión, por ejemplo 2.0)
se fijará la versión de la práctica a la versión del servidor donde se cree (versión 2.0).
La interfaz implementada en cada servidor podrá variar, debido a que pueden
pertenecer a servidores con versiones diferentes.
Siguiendo con el ejemplo, se va a modificar la versión del servidor (tabla versiones). Se
trata, por ejemplo, de la versión 2 con alias 2.0, en campos extras se va a poner 1 (ya
que se ha añadido el campo filtro de optimización con respecto a la primera versión) y
en comentarios se va a especificar el motivo de crear esta nueva versión: Manejo de
prácticas tipo C++ con la posibilidad de activar, para estas prácticas, el filtro de
optimización.
Para modificar la versión del servidor, tan sólo se tiene que pulsar editar y rellenar los
campos debidamente.
Figura 56: Modificación tabla versiones
Queda pendiente modificar la interfaz. Hay que analizar el fichero practica.xtpl
(carpeta html). Al pulsar en la entrada del menú lateral crear práctica se ejecuta la
tarea addPractica, esta tarea muestra por pantalla el formulario a rellenar con los
datos de la nueva práctica. Este formulario se encuentra definido en el fichero
practica.xtpl, la tarea añade dicho fichero a la plantilla template.html.
Se debe añadir en practica.xtpl un nuevo elemento de tipo radio (o más
concretamente un conjunto de elementos de formulario de tipo circular, en los que el
usuario debe optar por uno sólo de ellos, que se marca con el ratón o tabulador)
semejante al utilizado en el filtro de sintaxis:
OPTIMIZE_FILTER: Es una constante y como tal se debe definir en los ficheros
spanish.php y english.php (pertenecientes a la carpeta languages):
define('OPTIMIZE_FILTER','Filtro de optimización'); para
spanish.php y define('OPTIMIZE_FILTER','Optimize filter');
para english.php. Se consigue mostrar en la interfaz el texto adecuado en función
del idioma.
name: Nombre de la variable que debe coincidir con el nombre del registro
correspondiente en la tabla prácticas. El nombre del registro es campo1 luego el
nombre de la variable debe ser el mismo. Al rellenar los datos de la práctica se
pulsa el botón Grabar y se carga nuevamente index.php ejecutándose el
método getVars. Este método permite recuperar las variables de tipo Get
(URL) y Post (formularios, como es el caso) en el array vars. Se ejecuta la tarea
scriptPractica para procesar correctamente en la base de datos la
información de la nueva práctica. En este punto, se sube la información a la tabla
prácticas (se realiza una consulta) con los nombres de los campos de la tabla y
sus respectivos valores.
CHECKEDFILTROOPTIMIZACIONSI : Gracias a esta variable se puede
seleccionar el parámetro checked en el radio botón Sí. De esta manera, se
consigue marcar por defecto este radio botón. Esto es útil a la hora de editar una
<tr>
<td class="key">{OPTIMIZE_FILTER}:</td>
<td><input type="radio" name="campo1" value="1"
{CHECKEDFILTROOPTIMIZACIONSI}>{YES} <input type="radio"
name="campo1" value="0"
{CHECKEDFILTROOPTIMIZACIONNO}>{NO}</td>
</tr>
práctica, ya que inicialmente se muestra el formulario rellenado con la
información actualmente vigente en la base de datos.
CHECKEDFILTROOPTIMIZACIONNO: Es análogo a
CHECKEDFILTROOPTIMIZACIONSI salvo que está referido al radio botón
No.
key: Es el nombre de la clase CSS que se utiliza. En las hojas de estilo se
especifica el formato (tamaño de las letras, tipo, color, grosor del recuadro...)
que debe tener esta clase. Se ha elegido, por ejemplo, la clase utilizada en el
resto de la interfaz (así Filtro de optimización aparecerá con el mismo
formato que Filtro de sintaxis, Plantilla...).
Por otro lado, es necesario contemplar este nuevo tipo de prácticas en el menú
despegable Tipo (inicialmente sólo se puede elegir entre prácticas tipo Matlab y tipo
C). Este elemento del formulario quedaría de la siguiente forma:
Se ha añadido una nueva entrada en el menú, llamada C++, de manera que si se elige
esta entrada se almacena en la variable tipo el valor 3. Las variables
CHECKEDTIPO1, CHECKEDTIPO2 y CHECKEDTIPO3 permiten seleccionar la
correspondiente entrada a la hora de editar una práctica.
<tr>
<td class="key">{TYPE}:</td>
<td><select name="tipo"><option value="1"
{CHECKEDTIPO1}>Matlab</option><option value="2"
{CHECKEDTIPO2}>C</option><option value="3"
{CHECKEDTIPO3}>C++</option></select></td>
</tr>
Figura 57: Modificación interfaz: Menú despegable Tipo
Figura 58: Modificación interfaz: Filtro de optimización
4.2. Creación de nuevos métodos
A la hora de crear nuevos métodos se debe alterar lo menos posible el core del
sistema. Hay casos en los que extender la funcionalidad del sistema implica la creación
de nuevos métodos debido a que no se contemplaba antes la función o debido a que el
método existente no vale para todas las prácticas en las que se contempla esta función
y sea necesario crear varios métodos.
Siguiendo con el ejemplo, en este caso es necesario crear un nuevo método ya que la
función filtro de optimización no estaba contemplada antes. El método se añadirá en la
clase Evaluacion.
Por el hecho de albergar en el sistema un nuevo tipo de prácticas, se deberá crear un
método que evalúe (utilizando para ello un compilador adecuado) las entregas de
estas prácticas a semejanza de evaluaEntregaMatlab o evaluaEntregaC.
Para la simulación de entregas, el método ajaxTestPractica habría que
modificarlo para que contemplara la simulación de entregas de tipo C++, actualmente
sólo contempla las entregas de tipo Matlab y C.
function
comprobarCompilacion($solucionalumno,$inicioprofesor)
{
…
}
//Determina si la solución propuesta es óptima.
function comprobarOptimizacion($solucionalumno)
{
…
}
function
comprobarSintaxisFiltrado($solucionalumno,$filtro)
{
…
}
Parte 2: Manual para el profesorado del Servidor de Docencia
Índice
0. Introducción .................................................................................................................. 92
1. Identificación en el servidor ........................................................................................... 93
2. Página de inicio del espacio de trabajo ........................................................................... 94
3. Grupos .......................................................................................................................... 96
3.1. Creación de un nuevo grupo ............................................................................................ 97
3.2. Ver grupo .......................................................................................................................... 98
3.3. Añadir alumnos a un grupo .............................................................................................. 99
3.4. Asignar práctica a grupo ................................................................................................. 100
3.5. Editar grupo .................................................................................................................... 102
3.6. Borrar grupo ................................................................................................................... 103
4. Ejercicios ..................................................................................................................... 105
4.1. Creación de una nueva práctica ..................................................................................... 106
4.2. Importar una práctica..................................................................................................... 108
4.3. Conjuntos de ejercicios .................................................................................................. 109
4.4. Asignar ejercicio a grupo ................................................................................................ 111
4.5. Borrar ejercicio ............................................................................................................... 111
4.6. Exportar ejercicio ........................................................................................................... 112
4.7. Simular entrega de un alumno ....................................................................................... 113
5. Asignaciones ................................................................................................................ 115
5.1. Asignaciones como profesor autorizado ........................................................................ 116
5.2. Editar asignación ............................................................................................................ 117
5.3. Borrar asignación ........................................................................................................... 117
5.4. Autorizar profesores ...................................................................................................... 118
6. Evaluaciones ................................................................................................................ 120
6.1. Paso 1: Seleccione un grupo .......................................................................................... 120
6.1.1. Últimas calificaciones .............................................................................................. 120
6.2. Paso 2: Seleccione un ejercicio/conjunto ...................................................................... 121
6.3. Paso 3: Evaluar ............................................................................................................... 122
7. Suscripciones ............................................................................................................... 126
8. Diagnósticos ................................................................................................................ 128
0. Introducción
Se presenta una aplicación web capaz de proporcionar una innovadora herramienta
educativa diseñada para automatizar la recolección, evaluación y detección de errores
en ejercicios prácticos asignados a estudiantes de ingeniería. El servidor de Docencia se
encuentra en dirección web
http://bono.us.es/sdocencia
Para el correcto funcionamiento de las páginas, su navegador debe permitir cookies y
la ejecución de JavaScript.
Entre los propósitos del sistema se encuentra el siguiente: Hacer posible para cada
alumno una parametrización o caracterización individual de los ejercicios. La gran
cantidad de posibles arquitecturas existentes en la ejecución de un código de un
alumno permiten llevar a cabo multitud de tests. La plataforma abierta del sistema
permite a un profesor implementar técnicas de enseñanza innovadoras. Gracias a ellas,
el alumno puede obtener información acerca de sus conocimientos continuamente a
lo largo de todo el curso.
1. Identificación en el servidor
Para acceder al sistema como profesor, un administrador ha tenido que registrar a
dicho profesor previamente con su DNI y Clave de usuario. Una vez efectuado el
registro, el profesor podrá acceder al sistema indicando el DNI y la Clave.
Figura 59: Formulario para iniciar sesión
Si se pulsa la casilla Recuérdame y el profesor accede al sistema (identificándose), si
decide salir de él sin cerrar de sesión, el profesor podrá acceder al sistema saltándose
el proceso de login.
Es posible recuperar la Clave, se debe pulsar en el enlace Recuperar contraseña e
introducir el DNI y la dirección de e-mail (dirección de correo empleada durante el
registro).
Figura 60: Formulario a rellenar para recuperar la Clave de usuario
2. Página de inicio del espacio de trabajo
Tras la identificación de usuario se accede a la página de inicio.
A través del menú lateral es posible acceder a:
Los grupos que el profesor identificado haya creado y a todas las acciones
vinculadas a los grupos: Crear nuevos grupos, añadir alumnos a un grupo, editar
grupo… Pulsando en la entrada Grupos.
Los conjuntos de ejercicios y prácticas creadas por el profesor, además de a todas
las acciones vinculadas: Asignar prácticas a grupos, crear nuevas prácticas,
modificarlas... Pulsando en la entrada Ejercicios.
Las asignaciones como profesor autorizado y asignaciones realizadas por el
profesor, además de a todas las acciones vinculadas: Editar una asignación,
borrar una asignación... Pulsando en la entrada Asignaciones.
Las últimas calificaciones de un grupo perteneciente al profesor y a todas las
acciones vinculadas: Evaluar a un grupo en una práctica, añadir comentarios...
Pulsando en la entrada Evaluaciones.
Las actividades (suscripciones) creadas por el profesor y a todas las acciones
vinculadas: Crear una actividad, editar una actividad, borrar una actividad…
Pulsando en la entrada Suscripciones.
El estado del servidor de evaluación Matlab.
Los datos (perfil) del profesor, actualizándolos si es conveniente pulsando en la
entrada Mis datos.
Al finalizar, se ofrece la posibilidad de cerrar sesión, pulsando en la entrada Logout.
Figura 61: Página de inicio del espacio de trabajo
3. Grupos
Un grupo es una lista de alumnos que se agrupan bajo un nombre común para
asignarles simultáneamente uno o varios trabajos. Por ejemplo, los alumnos de 3er
curso de Ingeniería de Telecomunicación pueden formar un grupo, o si es necesario
por cuestiones de organización (aulas, profesorado), pueden estar divididos en varios
grupos o subgrupos.
Un grupo puede estar formado por varios subgrupos, permitiendo asignar prácticas a
subgrupos concretos y no a la totalidad del grupo. Por ejemplo, puede interesar
asignar a todos los subgrupos de un grupo el mismo ejercicio pero con pequeñas
modificaciones: Variación de la fecha inicial/final de entrega, habilitación filtro IP…
Al pulsar en la entrada Grupos se muestra una tabla con todos los grupos existentes
(grupos creados por el profesor identificado en el sistema).
Figura 62: Listado de grupos del profesor
Cada fila se corresponde con un grupo y a través de las columnas de la tabla se
organiza la información de cada grupo. La información mostrada de cada grupo es la
siguiente:
ID: identificador del grupo.
ASIGNATURA: Nombre de asignatura a la que pertenece el grupo.
NOMBRE DEL GRUPO: Nombre que se le asigna al grupo.
TITULACIÓN: Nombre de la titulación a la que pertenece el grupo.
AÑO: Año en el que se desarrolla el curso académico.
ALUMNOS: Número de alumnos totales que contiene el grupo (incluyendo posibles
subgrupos).
SUBGRUPOS: Número de subgrupos dentro del grupo.
OPCIONES: Posibles acciones a realizar sobre un grupo (ver grupo, añadir alumnos
a un grupo, asignar práctica a grupo, editar grupo y borrar grupo). En los
apartados 3.2, 3.3, 3.4, 3.5 y 3.6 se explican cada una de las
posibles acciones.
Se observa en la entrada Grupos del menú lateral un submenú con dos nuevas
entradas:
Listado de grupos: Permite volver a la página inicial antes comentada en la
que se enumeran y se muestran los grupos existentes.
Crear un grupo: Permite crear un nuevo grupo. Al pulsar en esta entrada se
muestra una página con un formulario para rellenar con los datos del nuevo
grupo. En el apartado 3.1 se expone un ejemplo práctico sobre la creación
de un nuevo grupo.
3.1. Creación de un nuevo grupo
Para crear un nuevo grupo, se debe pulsar en la entrada del submenú lateral Crear
un grupo, mostrándose un formulario a rellenar con los datos del nuevo grupo.
Se va a crear, por ejemplo, un nuevo grupo llamado a, perteneciente a la asignatura
Automatismos de 5º curso de Ingeniería de Telecomunicación.
El año del curso académico es 2009. Es necesario subir un fichero de texto plano
(formato CSV) con los alumnos que van a formar parte del grupo. En principio,
únicamente puede haber un subgrupo, que es todo el grupo.
Sólo resta pulsar Grabar para crear el grupo a. Finalmente, se muestra de nuevo la
página inicial en la que se listan los grupos existentes, apareciendo una nueva fila
asociada al grupo que se acaba de crear. En la parte superior de la página aparece un
mensaje indicando que el grupo se ha creado correctamente.
Figura 63: Formulario para creación nuevo grupo
Figura 64: Nuevo grupo creado
3.2. Ver grupo
Si se quiere ver los alumnos que componen un grupo se debe pulsar la entrada Ver
grupo de la columna OPCIONES.
Se muestra una tabla en la que se listan todos los alumnos que pertenecen a un
determinado grupo, indicando el subgrupo al que pertenece cada alumno.
En la columna CLAVE se brinda la posibilidad de resetear las Claves de usuario de los
alumnos.
Es posible eliminar alumnos, seleccionando los alumnos que se desean borrar o
seleccionando todos los alumnos del grupo, tras ello, pulsar Borrar
seleccionados.
Figura 65: Borrado de los alumnos del grupo
3.3. Añadir alumnos a un grupo
Si se quiere añadir alumnos a un grupo concreto se debe pulsar la entrada Añadir
alumnos a un grupo de la columna OPCIONES.
Se va a añadir alumnos, por ejemplo, al grupo a de la asignatura Automatismos.
Al pulsar en la entrada, se invita a que el profesor seleccione la manera con la que va a
subir los alumnos: Vía fichero de texto plano (formato CSV) o manualmente.
Se elige, por ejemplo, la opción manualmente. Se muestra un formulario a rellenar con
el nombre y DNI (sin letra) del alumno que se quiere añadir al grupo. Se debe elegir
también el subgrupo al que pertenecerá el alumno, ofreciendo la posibilidad de
ubicarlo en un nuevo subgrupo.
Siguiendo con el ejemplo, se va a crear un nuevo subgrupo.
Figura 66: Formulario para añadir alumnos a un grupo manualmente
Tan sólo resta pulsar Grabar. Finalmente, se muestra la página inicial en la que se
listan los grupos existentes. Se observa como el número de estudiantes se ha
incrementado en uno y el número de subgrupos también, en la parte superior de la
página aparece un mensaje indicando que el alumno se ha añadido correctamente.
Figura 67: Nuevo alumno añadido al grupo
Si se elige la opción añadir alumnos a través de un fichero de texto plano (formato
CSV), se añaden automáticamente todos los alumnos que figuren en el fichero
permitiéndose, al igual que en la opción manual, crear un nuevo subgrupo a la hora de
seleccionar el subgrupo.
Figura 68: Formulario para añadir alumnos a través de fichero de texto plano (formato CSV)
El fichero de texto plano debe tener un formato conocido y concreto: Debe tener una
columna con los DNIs de los alumnos (encabezada por D.N.I.) seguida de otra
columna con los nombres y apellidos; Siendo configurables estas características. El
mismo formato debe tener el fichero de texto plano empleado a la hora de crear un
nuevo grupo.
3.4. Asignar práctica a grupo
Si se quiere asignar una práctica a un grupo se debe pulsar en la entrada Asignar
ejercicio a grupo de la columna OPCIONES. Una vez realizada la asignación, los
alumnos del grupo podrán enviar las soluciones de la práctica para ser evaluados
posteriormente.
Se va a asignar, por ejemplo, la práctica IAER Práctica2-Ejercicio1 al grupo
a de Automatismos.
Al pulsar en la entrada, se muestra un formulario a rellenar con las características de la
asignación.
Figura 69: Formulario para realizar asignación práctica - grupo
El campo Estado determina el estado en el que se va a encontrar la asignación:
Activa o inactiva.
Asignatura: El nombre de la práctica que se quiere asignar al grupo.
Grupo: El nombre del grupo al que se quiere asignar la práctica.
Subgrupo: El subgrupo, dentro del grupo, al que se quiere realizar realmente la
asignación.
Fecha inicial: La fecha de inicio de la asignación (fecha inicial a partir de la
cual los alumnos del grupo pueden realizar la práctica siempre y cuando la
asignación se encuentre activa).
Fecha final: La fecha fin de la asignación.
Fecha final retrasada: Determina (junto con la hora final) si un ejercicio
pertenece a la tabla de ejercicios activos o a la tabla de ejercicios antiguos (en
este último caso, no se podrá realizar nuevas entregas).
Hora final: Hora límite de la asignación.
Mostrar calificaciones: Si se desea mostrar las notas una vez realizada la
evaluación a los alumnos.
Mostrar comentarios: Si se desea mostrar los comentarios generados por el
evaluador a los alumnos.
Filtro IP: Si se quiere habilitar un filtro de direcciones IP (estableciendo la IP
inicial y la final).
Filtro de sintaxis: Habilita o deshabilita el filtro de sintaxis (permite
detectar si la solución propuesta por el alumno presenta errores de sintaxis,
tanto en prácticas tipo C como tipo Matlab). Este filtro se contempla a la hora de
realizar un alumno una entrega, a la hora de lanzar una evaluación y al simular
una entrega de un alumno.
Mostrar nota profesor: Si se desea mostrar la nota generada por el profesor
a los alumnos.
Mostrar comentarios profesor: Si se desea mostrar los comentarios
generados por el profesor a los alumnos.
Mostrar envíos pasados: Establece si se permite mostrar a los alumnos su
último envío a la hora de realizar una nueva entrega o de consultar ejercicios
antiguos.
Editar profesores autorizados: Establece los profesores a los que se les
permiten editar la asignación. Se especifica los DNIs de dichos profesores
separados por un espacio en blanco.
3.5. Editar grupo
Si se quiere editar un grupo existente se debe pulsar en la entrada Editar grupo de
la columna OPCIONES.
Siguiendo con el ejemplo, se va a editar el grupo a de Automatismos. Se va a
modificar el nombre del grupo, el grupo va a llamarse aa.
Al pulsar en la entrada se muestra un formulario con la información actual del grupo.
Para actualizar cualquier campo tan sólo hay que modificar el contenido del campo,
finalmente pulsar Grabar.
Figura 70: Editar grupo
Tras pulsar Grabar, se muestra de nuevo la página inicial en la que se listan los grupos
existentes. Se puede observar como el nombre del grupo ha cambiado, en la parte
superior de la página aparece un mensaje indicando que el grupo de ha modificado
correctamente.
Figura 71: Grupo editado
3.6. Borrar grupo
Si se quiere borrar un grupo se debe pulsar en la entrada Borrar grupo de la
columna OPCIONES.
Para borrar un grupo hay que analizar el estado del mismo:
Si el grupo posee prácticas asignadas y alumnos: No es posible eliminar el grupo,
ya que posee prácticas asignadas. Se muestra un mensaje por pantalla indicando
el estado del grupo y la imposibilidad de eliminarlo. Se debe pulsar Aceptar
para volver a la página en la que se listan los grupos existentes.
Si posee únicamente prácticas asignadas: No es posible eliminar el grupo, ya que
posee prácticas asignadas. Se procede de igual forma que en el caso anterior.
Si posee únicamente alumnos: Es posible eliminar el grupo. Se muestra un
mensaje por pantalla indicando el estado del grupo.
Si no posee alumnos ni prácticas asignadas: Es posible eliminar el grupo. Se
muestra un mensaje por pantalla indicando el estado del grupo.
En el caso de que se proceda a eliminar un grupo que posea subgrupos, si los
subgrupos no poseen prácticas asignadas, el grupo podrá ser eliminado arrastrando en
la eliminación todos los subgrupos que albergue.
Figura 72: Borrar grupo con alumnos
Figura 73: Borrar grupo con prácticas asignadas y alumnos
4. Ejercicios
Una práctica (ejercicio) es una tarea diseñada por el profesor y que puede ser asignada
a uno o a varios grupos de alumnos. El ejercicio es resuelto individualmente por cada
alumno y almacenado en el Servidor de Docencia para su posterior evaluación
automática.
Al pulsar en la entrada Ejercicios del menú lateral se muestra una tabla con todas
las prácticas pertenecientes al profesor identificado en el sistema.
Figura 74: Tabla con las prácticas del profesor
Cada fila se corresponde con una práctica y a través de las columnas de la tabla se
organiza la información de cada práctica. La información mostrada de cada práctica es
la siguiente:
ID: Identificador de la práctica.
NOMBRE: Nombre que se le ha dado a la práctica. Si se pulsa en el nombre se
accede al formulario del apartado creación de una nueva
práctica, relleno con la información actual de la práctica, permitiéndose
modificar los campos oportunos, editando de esta manera la práctica.
FECHA: Fecha en la que se ha subido por primera vez la práctica al servidor.
DESCRIPCIÓN: Breve descripción de la práctica.
ENUNCIADO: Muestra si la práctica tiene enunciado o no. El enunciado será un
fichero PDF que se subirá al servidor en el momento de creación de la práctica o
al editarla. Si la práctica posee enunciado, al pulsar Sí se mostrará el enunciado.
TIPO: Indica el tipo de práctica. Práctica tipo Matlab o tipo C.
VER.EVAL: Versión de la evaluación, indica la versión del servidor en el que se ha
creado o modificado la práctica. Este parámetro se utiliza a la hora de importar
prácticas.
OPCIONES: Posibles acciones a realizar sobre una práctica (asignar ejercicio a
grupo, borrar ejercicio, exportar ejercicio, simular entrega de un alumno). En los
apartados 4.4, 4.5, 4.6 y 4.7 se explican cada una de las posibles
acciones.
Por otro lado se observa que en la entrada Ejercicios del menú lateral aparece un
submenú con cuatro nuevas entradas:
Listado: Permite volver a la página inicial antes comentada en la que se listan
las prácticas.
Crear: Permite crear una nueva práctica. Al pulsar en esta entrada se muestra
una página con un formulario para rellenar con los datos de la nueva práctica. En
el apartado 4.1 se expone un ejemplo práctico sobre la creación de una
nueva práctica.
Importar: Permite importar una práctica que ha sido previamente exportada
(generándose un archivo ZIP). En el apartado 4.2 se expone un ejemplo
práctico sobre la importación de una práctica.
Conjuntos de ejercicios: Permite crear y editar conjuntos de ejercicios. En
el apartado 4.3 se expone un ejemplo práctico. Los conjuntos de ejercicios
permiten agrupar las prácticas que el profesor vea oportunas, tratándolas como
un único bloque a la hora asignarlas a grupos o de lanzar evaluaciones. Es una
forma de facilitar la tarea del profesor en situaciones en las que debe asignar
varias prácticas a grupos, pudiendo ser el número de éstas elevado, ahorrando
un importante tiempo.
4.1. Creación de una nueva práctica
Para crear una nueva práctica se debe pulsar en la entrada del submenú lateral Crear,
mostrándose un formulario a rellenar con los datos de la nueva práctica.
Se va a crear una nueva práctica llamada práctica_prueba. El campo
Descripción representa una descripción de la práctica que se está creando, del
mismo modo, el campo Enunciado representa un breve enunciado de la práctica
ofreciendo la posibilidad de incluir un fichero PDF del enunciado detallado. El tipo de
prácticas que se va a elegir es, por ejemplo, Matlab. El campo Variables
iniciales representa las variables que son necesarias para poder ejecutar el código
del alumno y el evaluador. El campo Evaluador representa el script que evalúa la
solución propuesta por el alumno estableciendo una nota. Se ofrece la posibilidad de
incluir fichero de utilidades (funciones específicas, librerías...) y archivos adjuntos por
parte del alumno, establecer un conjunto de palabras prohibidas que el alumno no
podrá utilizar en su solución (palabras reservadas al sistema) las cuales pueden
permanecer ocultas al alumno o no, establecer la platilla que se mostrará al alumno
para que escriba en ella su solución así como la activación o no de un conjunto de
filtros que dependerán de la versión del servidor que se esté utilizando.
Se puede configurar que sea el servidor el que lance la ejecución del código del alumno
o sea el propio evaluador (esto es útil en prácticas en las que se ejecuta varias veces el
código del alumno para asegurar su funcionamiento).
Se puede configurar que al evaluar un grupo completo se realice una evaluación
modo ranking. Si se selecciona lanzar la evaluación de manera normal, se evaluará a
cada alumno individualmente obteniéndose la nota de cada uno. Al seleccionar lanzar
la evaluación en modo ranking, se obtiene el valor de un determinado parámetro
llamado rendimiento para cada alumno (por ejemplo, tiempo de subida de un
sistema en bucle cerrado). La nota de un alumno se calcula teniendo en cuenta el valor
del parámetro obtenido por él y por todos los restantes alumnos.
Es posible determinar una serie de errores que estarán exentos de Mlint. En prácticas
tipo Matlab seleccionar el filtro de sintaxis conlleva la ejecución de la función de
Matlab Mlint. Mlint es muy sensible en la detección de errores y hay casos en los que
genera errores que no es deseable que se contemplen como tal. Dichos errores se
especifican en el campo Errores exentos de MLINT.
Figura 75: Creación de una práctica I
Figura 76: Creación de una práctica II
Finalmente se pulsa Grabar, mostrándose la página inicial en la que se listan las
prácticas. Se puede observar como en la parte superior de la página aparece un
mensaje indicando que la práctica se ha creado correctamente.
Figura 77: Ejercicio creado
A la hora de crear una práctica tipo C se observa que no aparece el campo errores
exentos de MLINT. Es debido a que al ejecutar el filtro de sintaxis en este caso no
se llama a la función Mlint, ya que Matlab esta vez no interviene, interviene el
programa Dev-Cpp de compilación. Tampoco aparece el campo Ejecutar código
alumno, ya que en este caso el procedimiento consiste siempre en montar en un
fichero el evaluador (aquí esta embebida las posibles variables iniciales) y la solución
del alumno para posteriormente compilarlo.
4.2. Importar una práctica
Para importar una práctica se debe pulsar en la entrada del submenú lateral
Importar, mostrándose un campo para especificar el directorio donde se encuentra
el fichero ZIP generado por el sistema al realizar la exportación de la práctica.
Figura 78: Importar práctica: Ruta al fichero ZIP
Tan sólo resta pulsar Enviar y la práctica se habrá creado en el servidor, en el espacio
de trabajo del profesor.
El fichero ZIP está contiene un fichero con extensión prac (almacena las características
de la práctica), un fichero PDF (enunciado de la práctica si posee) y un fichero ZIP
(fichero de utilidades si posee).
Se analiza si la versión de la práctica que se quiere importar es inferior o igual a la
versión del servidor destino. En caso afirmativo se procede con la importación de la
práctica, en caso contrario, no se importa y se muestra un mensaje de error.
4.3. Conjuntos de ejercicios
Para crear o editar un conjunto de ejercicios se debe pulsar en la entrada del submenú
lateral Conjuntos de ejercicios.
Para crear un conjunto se pulsa en Crear conjunto, mostrándose un formulario a
rellenar con las características del nuevo conjunto. Se especifica el nombre del
conjunto y se seleccionan las prácticas que compondrán el conjunto.
Por ejemplo, se va a crear un nuevo conjunto llamado conjunto de ejercicios
de prueba, seleccionando las prácticas Fibonacci y Fibonacci2.
Figura 79: Crear un nuevo conjunto de ejercicios
Tan sólo resta pulsar Grabar, tras ello, se redirecciona, mostrándose un mensaje
indicando que el conjunto se ha creado correctamente.
Figura 80: Conjunto de ejercicios creado correctamente
Si se desea editar un conjunto existente, se debe pulsar en Editar conjunto. Se
listan en una tabla los conjuntos, seleccionando aquel que se desea editar.
En la columna OPCIONES se ofrece la posibilidad de asignar un conjunto de ejercicios
a un determinado grupo y de eliminar un conjunto.
Figura 81: Editar un conjunto de ejercicios
Por ejemplo, se va a editar el conjunto creado anteriormente. Se va a añadir una
práctica más al conjunto, la práctica Fibonacci3.
Figura 82: Editar el conjunto conjunto de ejercicios de prueba
El formulario a la hora de asignar un conjunto a un determinado grupo es análogo al
expuesto en el apartado 4.4.
A la hora de borrar un conjunto, se comprueba que el conjunto que se desea eliminar
no haya sido asignado a ningún grupo. Si hay alguna asignación, se muestra un
mensaje indicando que se debe borrar antes las asignaciones.
4.4. Asignar ejercicio a grupo
Se trata de la misma acción que la presentada en el apartado 3.4.
4.5. Borrar ejercicio
Si se quiere borrar un ejercicio se debe pulsar en la entrada Borrar ejercicio de la
columna OPCIONES.
Al pulsar la entrada se muestra una pantalla de confirmación. Al confirmar que se
desea borrar la práctica, se borrará siempre y cuando la práctica no esté asignada a
ningún grupo o subgrupo, ya que en ese caso no se borrará y se mostrará la página
inicial en la que se listan las prácticas mostrando un mensaje que indique este hecho.
Figura 83: Página de confirmación para borrar ejercicio
El borrado de asignaciones es una acción que pertenece a las opciones de la entrada
del menú lateral Asignaciones.
Figura 84: Borrado de un ejercicio asignado a grupos
A la hora de borrar una práctica se borran también los ficheros vinculados a ella
(enunciado y fichero de utilidades).
4.6. Exportar ejercicio
Permite exportar una práctica a un ordenador personal, generándose un archivo ZIP en
el que esta contenido el enunciado de la práctica (si es que tiene), un archivo de
extensión prac que almacena la configuración de la práctica y el archivo ZIP fichero de
utilidades (si es que tiene). Este concepto casa con importar práctica.
Para ello se debe pulsar en la entrada Exportar ejercicio de la columna
OPCIONES, tras ello aparecerá una ventana para especificar la ruta donde se quiere
guardar el fichero ZIP.
Figura 85: Exportar una práctica
4.7. Simular entrega de un alumno
Permite simular la entrega de una práctica como si el profesor fuera un alumno. Por
ejemplo, se desea hacer comprobaciones sobre la práctica que ha sido creada.
Se debe pulsar en la entrada Simular entrega de un alumno de la columna
OPCIONES. Tras ello, aparecerá (depende de la configuración y tipo de la práctica) una
página con el enunciado, palabras prohibidas, las variables iniciales, la plantilla para
escribir en ella la solución de la práctica y un campo para introducir el DNI (es diferente
a la situación real de entrega de un alumno, en este caso se tiene al alumno
identificado y se posee todo sus datos, como el DNI).
Figura 86: Simular entrega de un alumno
Tras escribir la solución en la plantilla sólo resta pulsar Enviar, mostrándose en la
misma página el resultado.
Figura 87: Simular entrega de un alumno - Resultado
Se contempla la posibilidad de aplicar el filtro de sintaxis (el asociado a la práctica y no
a la asignación ya que no hay asignación alguna), comprobación de la existencia de
palabras prohibidas en la solución enviada y distinción del tipo de prácticas (C,
Matlab…).
Para el correcto funcionamiento de la simulación, la práctica involucrada debe estar
configurada para que sea el servidor y no el evaluador (para prácticas tipo Matlab) el
que lance la ejecución de la solución propuesta por el alumno.
5. Asignaciones
Al asignar una práctica a un grupo se establece que dicha práctica debe ser realizada
por los alumnos del grupo en el plazo que se indique a la hora de llevar a cabo la
asignación, configurando además otros aspectos, como por ejemplo, si se quiere que
se muestre los comentarios del profesor a la hora de la evaluación.
Al pulsar en la entrada Asignaciones del menú lateral se muestra una tabla con
todas las asignaciones pertenecientes al profesor identificado en el sistema.
Figura 88: Asignaciones realizadas por el profesor
Cada fila se corresponde con una asignación y a través de las columnas de la tabla se
organiza la información de cada asignación. La información mostrada de cada
asignación es la siguiente:
ESTADO: Muestra el estado en el que se encuentra la asignación. Es posible
invertir el estado de la asignación pulsando sobre él.
EJERCICIO/CONJUNTO: Nombre del ejercicio o del conjunto de ejercicios.
GRUPO: Nombre del grupo al que se le ha asignado el ejercicio o el conjunto de
ejercicios. Si se coloca el cursor sobre el nombre se muestra el subgrupo
concreto al que se le ha asignado el ejercicio o el conjunto de ejercicios.
INICIO: Fecha de inicio de la asignación (fecha inicial a partir de la cual los
alumnos del grupo pueden realizar la práctica siempre y cuando la asignación se
encuentre activa).
FINAL: Fecha fin de la asignación (especificando la hora de finalización). Si se
coloca el cursor sobre la fecha se muestra la fecha final retrasada (fecha utilizada
para la distinción entre ejercicios activos y ejercicios antiguos).
NOTAS VISIBLE: Indica si se desea mostrar las notas (notas generadas por el
evaluador), una vez realizada la evaluación, a los alumnos.
COMENTARIOS VISIBLE: Indica si se desea mostrar los comentarios generados
por el evaluador a los alumnos.
FILTRO IP: Permite habilitar un filtro de direcciones IP (estableciendo la IP
inicial y la final).
NOTAS PROFESOR: Indica si se desea mostrar la nota generada por el profesor a
los alumnos.
COMENTARIOS PROFESOR: Indica si se desea mostrar los comentarios generados
por el profesor a los alumnos.
OPCIONES: Posibles acciones a realizar sobre una asignación (editar asignación,
borrar asignación y autorizar profesores). En los apartados 5.2, 5.3 y
5.4 se explican cada una de las posibles acciones.
Se observa que en la entrada Asignaciones del menú lateral aparece un submenú
con una nueva entrada: Asignaciones como profesor autorizado. Al pulsar
en dicha entrada, se accede a una tabla en la que se listan todas las asignaciones que
posea el profesor como profesor autorizado, permitiendo editarlas. En el apartado
5.1 se muestra un ejemplo práctico sobre la modificación de una asignación como
profesor autorizado.
5.1. Asignaciones como profesor autorizado
Permite editar asignaciones como profesor autorizado. Se debe pulsar en la entrada
del submenú Asignaciones como profesor autorizado.
Se accede a una tabla en la que se listan las asignaciones como profesor autorizado
que posea el profesor. En la columna OPCIONES se permite editar una asignación
concreta. En la tabla se muestra información relativa a cada asignación, lo novedoso
respecto a la tabla en la que se listan todas las asignaciones son los siguientes campos:
ENVÍOS PASADOS
FILTRO SINTAXIS
Figura 89: Asignaciones como profesor autorizado
Para editar una asignación se debe pulsar le entrada Editar asignación de la
columna OPCIONES. Se muestra el formulario ya descrito en el apartado Asignar
práctica a grupo mostrando, en esta ocasión, la información actual de la
asignación. Se observa que hay determinados campos fijos (no se pueden modificar),
por ejemplo, Ejercicio/Conjunto.
Figura 90: Editar asignación como profesor autorizado
5.2. Editar asignación
Permite editar una asignación creada previamente, actualizando los campos oportunos
del formulario relativo a asignar una práctica a un grupo mostrando, en esta ocasión, la
información actual de la asignación.
Para ello se debe pulsar la entrada Editar asignación de la columna OPCIONES.
5.3. Borrar asignación
Si se quiere borrar una asignación (práctica/conjunto de ejercicios - grupo o
práctica/conjuntos de ejercicios - subgrupo) se debe pulsar en la entrada Borrar
asignación de la columna OPCIONES.
Al pulsar la entrada se muestra una pantalla de confirmación. Al confirmar que se
desea borrar la asignación se borrará, siempre y cuando no haya entregas realizadas
por parte de los alumnos ya que en ese caso no se borrará y se mostrará la página
inicial en la que se listan las asignaciones mostrando un mensaje que indique este
hecho. Si se cumple, se borra la asignación elegida y se muestra un mensaje, indicando
que la operación de borrado ha tenido éxito.
Un profesor que realiza una asignación, puede autorizar a otros profesores a editar la
asignación. Si el profesor decide borrar la asignación, se borran automáticamente las
posibles autorizaciones que hubiera.
Figura 91: Página de confirmación para borrar asignación
Figura 92: Borrado de una asignación con entregas realizadas
5.4. Autorizar profesores
Permite autorizar a nuevos profesores a editar la asignación. Para ello se debe pulsar la
entrada Autorizar profesores de la columna OPCIONES.
Se listan en una tabla todos los DNIs de los profesores a los que se les permiten
modificar la asignación. En la columna OPCIONES, se ofrece la posibilidad de editar o
borrar un DNI concreto.
Para añadir nuevos DNIs de profesores autorizados, se debe pulsar Añadir ID.
Figura 93: Autorizar a profesores a editar la asignación
Figura 94: Añadir un nuevo profesor autorizado
Figura 95: Editar un DNI concreto
6. Evaluaciones
Para evaluar a un grupo en una práctica (o conjunto de ejercicios) que tenga asignada
o para obtener sus últimas calificaciones en todas las prácticas que tenga asignadas, es
necesario pulsar en la entrada Evaluaciones del menú lateral.
6.1. Paso 1: Seleccione un grupo
Al pulsar en la entrada, se muestra una tabla con todos los grupos pertenecientes al
profesor identificado en el sistema (la información asociada a cada grupo es la
mostrada en el apartado Grupos). Esta etapa se corresponde con el paso 1, en el
que se selecciona el grupo que se quiere evaluar.
Figura 96: Calificaciones: Paso 1 - Seleccionar un grupo
Las posibles opciones a realizar sobre cada grupo son en este caso: Mostrar las últimas
calificaciones y seleccionar un grupo a evaluar para acceder al Paso 2.
6.1.1. Últimas calificaciones
La entrada Últimas calificaciones de la columna OPCIONES permite descargar
las últimas calificaciones del grupo en un fichero Excel.
En dicho fichero, aparecerán las calificaciones obtenidas en todas las prácticas que
tenga asignadas el grupo seleccionado, cada una en una columna.
Dichas calificaciones corresponden a la última evaluación automatizada que se haya
realizado en cada práctica. Por ello, si se desea garantizar que la hoja de cálculo esté
actualizada, es preciso entrar previamente en cada una de las asignaciones y lanzar
una evaluación.
Al pulsar la entrada, se abre una ventana que permite seleccionar la ruta donde se
quiere guardar el fichero Excel.
Figura 97: Últimas calificaciones: Guardar archivo Excel
6.2. Paso 2: Seleccione un ejercicio/conjunto
Una vez seleccionado un grupo (Paso 1), se debe seleccionar un ejercicio o conjunto de
ejercicios de los que tenga asignado.
Se muestra una primera tabla con los diferentes ejercicios que tiene el grupo
seleccionado asignado (la información asociada a cada ejercicio es la mostrada en el
apartado Ejercicios).
Se muestra una segunda tabla con los diferentes conjuntos de ejercicios que tiene el
grupo seleccionado asignado. Esta sección se encuentra en desarrollo actualmente.
Figura 98: Calificaciones: Paso 2 - Seleccionar un ejercicio
Figura 99: Calificaciones: Paso 2 - Seleccionar un conjunto de ejercicios
Para seleccionar el ejercicio (o conjunto de ejercicios) en el que se quiere evaluar al
grupo se debe pulsar en Seleccionar.
6.3. Paso 3: Evaluar
Una vez seleccionado el ejercicio (Paso 2), ya se puede realizar la evaluación del grupo
seleccionado en el ejercicio seleccionado.
Se muestra una tabla con los diferentes alumnos del grupo. Cada fila se corresponde
con un alumno y a través de las columnas de la tabla se organiza la información de
cada alumno. La información mostrada de cada alumno es la siguiente:
Nombre y DNI
Estado de la entrega: Si el alumno ha realizado la entrega (Entregada) o no (No
entregada).
Si se ha realizado entrega: Fecha y hora en la que se ha realizado la entrega, si se
ha subido o no fichero adjunto y nota especificada por el profesor.
Si se ha evaluado previamente al alumno: Nota generada por el evaluador.
Figura 100: Calificaciones: Paso 3 - Evaluar
La evaluación puede realizarse individualmente, pulsando Evaluar en la fila asociada
al alumno que se desea evaluar o de todo el grupo, pulsando donde se indica en la
página.
En la parte superior de la página se observa un resumen de la información más
relevante acerca del grupo, asignación y práctica seleccionada así como la fecha de la
última evaluación.
El profesor puede seleccionar, al crear o editar una práctica, el modo en que se desea
que se lance una evaluación de un grupo completo. Si se selecciona lanzar la
evaluación de manera normal, se evaluará a cada alumno individualmente
obteniéndose la nota de cada uno. Al seleccionar lanzar la evaluación en modo
ranking, se realiza el mismo proceso que antes, obteniéndose el valor de un
determinado parámetro llamado rendimiento para cada alumno. Este parámetro
determinará la nota definitiva que tendrá cada alumno. El evaluador, en este último
caso, no proporciona la nota sino un parámetro arbitrario, por ejemplo, el tiempo de
subida en un sistema de control. La nota de un alumno se calcula teniendo en cuenta
el valor del parámetro obtenido por él y por todos los restantes alumnos. El profesor
fija en el evaluador de la práctica la nota máxima (variable notamax) y la nota mínima
(variable notamin) que desea que tengan los alumnos. El procedimiento es el
siguiente:
Se ordenan de mayor a menor los rendimientos obtenidos por los alumnos.
Se calcula el número de alumnos efectivos: Número de alumnos que han realizado
entrega, con rendimientos positivos y cuyos rendimientos sólo aparezcan una
vez.
Se calcula el factor para el cálculo de las notas: El factor es el resultado de restar
la nota máxima con la nota mínima y el resultado, dividirlo entre el número de
alumnos efectivos.
Se calculan las notas asociadas a cada entrega: Al rendimiento más alto se le
asocia la nota mínima, al siguiente rendimiento menor se le asocia la nota
mínima más el factor, al siguiente rendimiento menor se le asocia la nota mínima
más dos veces el factor y así sucesivamente. Rendimientos iguales implican notas
iguales. Rendimiento negativo implica nota igual a cero.
Si se solicita evaluar a un alumno concreto en una práctica configurada en modo
ranking se rechazará la petición.
Si se ha realizado una entrega, es posible pulsar sobre el estado de la entrega
(Entregada) para acceder a un nuevo formulario en el que se permite:
Ver y modificar la solución del alumno.
Especificar los comentarios del profesor.
Ver los comentarios del evaluador (si se ha lanzado previamente la evaluación).
Especificar la nota del profesor.
Figura 101: Ver entrega del alumno I
Figura 102: Ver entrega del alumno II
Para evaluar a un subgrupo, se procede de manera análoga. Tras seleccionar el grupo,
se elige la asignación asociada al subgrupo en cuestión. Finalmente, se muestra una
tabla con las notas de los alumnos pertenecientes al subgrupo, además de toda la
información y opciones antes mencionadas.
7. Suscripciones
Lista en una tabla todas las actividades pertenecientes al profesor identificado en el
sistema. Muestra información de cada actividad (estado, nombre, grupo, subgrupo,
número de sesiones, número de alumnos inscritos…) y permite editar y borrar una
actividad, además ofrece la posibilidad de ver sus sesiones.
Figura 103: Lista de actividades
Hay asignaturas que requieren la creación de actividades. Se tratan de asignaturas que
poseen un número elevado de prácticas, prácticas que tienen lugar en determinadas
aulas con una duración determinada y en días y horarios específicos. En este contexto
toma sentido la creación de una actividad vinculada a la asignatura, la cual poseerá un
cuadrante en el que se especifica las sesiones que posea.
En el submenú lateral se encuentra la entrada Crear, la cual permite crear una nueva
actividad (suscripción). Al pulsar Crear, se accede a los formularios correspondientes
a los diferentes pasos en los que se divide la creación de una actividad. Pasos:
Paso 1: Seleccione un grupo: Permite seleccionar el grupo al que
pertenece la actividad. Admite la elección de un subgrupo concreto del grupo.
Figura 104: Paso 1: Selección grupo - subgrupo
Paso 2: Crear nueva actividad: Crea una nueva actividad. Se especifica
sus principales características, por ejemplo: Número de alumnos por turno,
nombre y descripción de la actividad o fecha inicial - final. Se permite crear
sesiones de manera automática. Con esta opción, se establecen algunos
parámetros por defecto, disminuyendo el tiempo empleado en la creación de la
actividad.
Figura 105: Paso 2: Creación actividad (modo manual)
A continuación, se establece el horario de los diferentes turnos, los días de la
semana con actividad, fechas puntuales en las que no hay actividad y finalmente
se genera un cuadrante provisional con todas las sesiones de la actividad. En el
cuadrante, se muestra información de cada sesión, además, se permite editar o
borrar una sesión.
8. Diagnósticos
Permite conocer el estado en el que se encuentra el servidor Matlab. El servidor puede
estar ocupado (realizando una evaluación), colgado (bucles infinitos en el código) o
corriendo (a la espera de recibir comandos) en el momento de realizar la consulta.
Si el servidor está ocupado o colgado se muestra al profesor una página en la que se le
ofrecen dos alternativas:
Se le invita a que vuelva a intentarlo pasados cinco minutos.
Forzar un reinicio del servidor Matlab: Se manda un correo a los administradores
del sistema informándoles de la incidencia.
En caso contrario, el servidor está corriendo y se notifica por pantalla al profesor.
Figura 106: Estado del servidor Matlab corriendo
top related