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