Resumen: El proyecto permite gestionar los proyectos de los

Departament d’Enginyeria Informàtica i M atemàtiques
Gestor de proyectos de investigación e I+D
Autor: Laura de Antonio Gómez
Director: Sergio Gómez
Fecha: 09 / 2010
Titulación: Ingeniería Técnica Informática de Gestión
Correo electrónico: [email protected]
Resum: El projecte permet gestionar els projectes per als diferents grups de recerca de la
universitat. Portarà un registre de tots els moviments dels diferents grups i un exhaustiu
historial financer.
La seva gestió es divideix segons cinc tipus de grups que tenen una interrelació entre ells:
els projectes, les tasques, els usuaris, la comptabilitat i el calendari. I en tres tipus de rols
per usuaris segons la seva responsabilitat: Administrador del sistema, coordinador del
projecte i investigador.
Els projectes encapsularan les tasques i la comptabilitat. Els usuaris seran distribuïts entre
els projectes i a la seva vegada entre les diferents tasques que els hi seran assignades on
estarà especificat el que han de fer. La comptabilitat registrarà els diferents moviments
dels diners que pertanyin al projecte. Totes les despeses seran guardades i els usuaris
podran consultar els estats dels pagaments de aquests. Cada usuari podrà tindre el seu
propi calendari on podrà marcar els diferents esdeveniments importants als que vol
assistir.
La estructura del projecte es basa en un servidor sota tecnologia J2EE i una base de dades
compatibles amb drivers JDBC. El llenguatge utilitzat es J2SE 1.6. S’utilitza el
framework Hibernate per la persistència i la consulta de dades amb el servidor de BD
mantenint el paradigma d'orientació a objectes. La base de dades guardarà totes les dades
dels projectes així com els permisos dels diferents usuaris per les seves validacions per
cada projecte. En conjunt amb J2EE utilitzarem el framework Struts2. Al ser un servei
web l’usuari podrà utilitzar qualsevol explorador de Internet per accedir.
Els jocs de proves han estat realitzats mitjançant JUnit per les funcionalitats de JAVA i
Selenium per la interface web.
2
Resumen: El proyecto permite gestionar los proyectos de los diferentes grupos de
investigación de la universidad. Llevará un registro de todos los movimientos de los
diferentes grupos y un exhaustivo historial financiero.
Su gestión se divide según cinco tipos de grupos que están interrelacionados entre ellos:
los proyectos, las tareas, los usuarios, la contabilidad y el calendario. Y en tres tipos de
roles para usuarios según su responsabilidad: administrador del sistema, coordinador del
proyecto e investigador.
Los proyectos encapsularan las tareas y la contabilidad. Los usuarios serán distribuidos
entre los proyectos y a su vez entre las diferentes tareas que les serán asignadas donde
estará especificado lo que han de hacer. La contabilidad registrara los diferentes
movimientos del dinero que pertenezca al proyecto. Todos los gastos serán guardados y
los usuarios podrán consultar el estado del pago de estos. Cada usuario podrá tener su
propio calendario donde poder señalar los diferentes eventos importantes a los que quiera
asistir.
La estructura del proyecto se basa en un servidor bajo tecnología J2EE y una base de
datos compatible con drivers JDBC. El lenguaje utilizado es J2SE 1.6. Se usa el
framework Hibernate para la persistencia y consultas de datos con el servidor de BD
manteniendo el paradigma de orientación a objetos. La base de datos guardará todos los
datos de los proyectos así como los permisos de los diferentes usuarios para sus
validaciones en cada proyecto. En conjunto con J2EE usaremos el framework Struts2. Al
ser un servicio web el usuario podrá utilizar cualquier explorador de internet para acceder.
Los juegos de pruebas se han realizado mediante JUnit para las funcionalidades de JAVA
y Selenium para la interface web.
3
Summary: The project allows project managing of different university research groups.
Also it will record all personal movements of different groups and save comprehensive
financial records.
The management is divided according to five groups related to each other: Projects,
Tasks, Users, Accounting and Calendar. The users will be classified within three user role
types and will be assigned according to their responsibility: System Administrator, Project
Coordinator, and Researcher.
The projects contain tasks and accountings. The users will be distributed between the
projects and the different tasks that will be assigned where they'll have specifications
about their research.At the accounting module will register the different movements of the
money that belongs to the project. All expenses will be saved and the users will be able to
query the payment state of them. Each user will have their own calendar where they can
annotate different important events to attend.
The project structure is based on J2EE server technology and the database must support
JDBC drivers. The language used is Java J2SE1.6. The persistence module use Hibernate
framework. This framework will be able to query the database server mantaining the
object oriented paradigm. The database will save all project's data as well as users'
permissions for every project. On top of J2EE we will be using Struts2 framework. The
application is a web service because the users can use any internet browser to utilize it.
The unitary test cases were programmed using JUnit framework for Java. Selenium was
used to test web interface.
4
Índice de contenido
1. Objetivos del proyecto.................................................................................................7
1.1.Contexto..................................................................................................................7
1.2.Objetivos..................................................................................................................8
2. Especificaciones del proyecto.....................................................................................9
3. Diseño..........................................................................................................................11
3.1 ¿En que consiste el proyecto?..............................................................................11
3.2 Estructura MVC...................................................................................................16
3.3 Diagrama Web......................................................................................................17
3.4. Diagrama BD.......................................................................................................19
3.5 Diagrama del flujo de Struts 2.............................................................................20
3.6 Diagrama de casos de uso....................................................................................24
3.6.1 Casos de uso para el Investigador.................................................................24
3.6.2 Casos de uso para el Coordinador.................................................................26
3.6.3 Casos de uso para el Administrador..............................................................29
3.7. Decisiones de diseño............................................................................................31
3.7.1. Tipos de calendario......................................................................................31
3.7.2. JQuery..........................................................................................................33
4. Desarrollo...................................................................................................................34
4.1 Problemas encontrados durante la fase de implementación..............................35
5. Evaluación..................................................................................................................36
5.1. Pruebas ...............................................................................................................36
5.1.1. JUnit.............................................................................................................36
5.1.2. Selenium.......................................................................................................37
5.2. Mejoras y limitaciones.........................................................................................38
5.2.1. Gráficos y tablas...........................................................................................38
5.2.2. Calendario de proyecto................................................................................39
5.2.3. Tarea.............................................................................................................39
5.2.4. Estructura interna.........................................................................................39
5.2.5. Framework...................................................................................................41
5.2.6. Exploradores de Internet..............................................................................41
6. Conclusiones...............................................................................................................44
6.1. Motivaciones........................................................................................................44
7. Recursos utilizados....................................................................................................45
7.1. Tecnologías utilizadas.........................................................................................45
7.2 Programas auxiliares...........................................................................................53
5
7.3. Bibliografía..........................................................................................................54
7.3.1. Páginas web..................................................................................................54
7.3.2. Libros...........................................................................................................54
8. Manuales.....................................................................................................................55
8.1. Instalación del entorno y configuración............................................................55
8.1.1. Entorno de desarrollo...................................................................................55
8.1.2. Entorno de producción.................................................................................62
8.1.3. Entorno de usuario.......................................................................................65
8.2. Manual de usuario..............................................................................................65
13.1.1. Proyecto......................................................................................................66
13.1.2 Tarea............................................................................................................72
13.1.3 Calendario...................................................................................................77
13.1.4. Usuario.......................................................................................................82
13.1.5 Contabilidad................................................................................................88
6
1. Objetivos del proyecto
1.1.Contexto
Los grupos de investigación universitarios y otros organismos públicos de investigación
consiguen el dinero para hacer la investigación de convocatorias competitivas organizadas
por ministerios, comunidades autónomas, organismos internacionales (e.g.. Unión
Europea), fundaciones y/o empresas privadas. Cuando se consigue un proyecto de
investigación, el responsable de la gestión del dinero concedido es el investigador
principal(IP). Habitualmente un mismo IP puede gestionar simultáneamente diferentes
proyectos de investigación, y los investigadores pueden también participar en los
proyectos de investigación de diferentes IP (no siempre es el mismo).
En la concesión del proyecto de investigación, la entidad financiadora habitualmente
decide la distribución definitiva del dinero concedido entre los diferentes años de
proyecto (que no coinciden necesariamente con años naturales), y como queda repartida
en las diferentes partidas del presupuesto: personal, material inventariable, material
fungible, gastos de desplazamiento, gastos de representación, etc.. Dichas partidas suelen
ser muy estrictas, de manera que no es fácil conseguir el permiso para poder transferir
dinero de una partida a otra. Es por ello que el IP necesita un control estricto y actualizado
de todos los gastos del proyecto.
Desafortunadamente, las universidades no suelen poner a disposición del IP las
herramientas informáticas necesarias para poder ejercer una gestión adecuada de sus
proyectos. Por ejemplo, sólo el personal de administración y servicios (PAS) pueden
acceder a parte de la información, y en muchas ocasiones no está correctamente
centralizada. En consecuencia, el IP depende básicamente de la habilidad del PAS para
gestionar dicha información, que a menudo no está actualizada y contiene errores. Los
problemas se agravan si además hay cambios en el PAS, e.g. por bajas o cambios de
destino.
7
1.2.Objetivos
Hacer una aplicación web para la gestión de proyectos de investigación que satisfaga los
siguientes requerimientos:
•
Permitir gestionar proyectos de investigación e I+D.
•
Permitir una visión global del proyecto al IP.
•
Permitir la organización y distribución de tareas entre investigadores.
•
Facilitar la gestión de la contabilidad.
•
Permitir la organización de eventos a nivel personal para cada investigador.
•
Realizar una página web dinámica en java con base de datos utilizando las
tecnologías de Hibernate, JQuery, JavaScript, Ajax, JUnit y Struts2.
8
2. Especificaciones del proyecto
El objetivo es realizar una aplicación para el IP que permita gestionar los proyectos de
investigación desde un punto de vista organizativo sobre un grupo de investigación así
como desde un punto de vista económico. Esta aplicación facilitará una visión global del
proyecto al IP en cualquier momento.
En un proyecto pueden participar muchos investigadores y no tienen porque trabajar
juntos o al mismo tiempo. Si además están a distancia esto dificulta más la comunicación.
La aplicación permitirá al IP la distribución de trabajo entre los diferentes componentes
del equipo y permitirá un seguimiento del trabajo de todo el grupo a tiempo real.
Los investigadores podrán participar en diferentes proyectos a la vez fácilmente. El
trabajo lo tendrán organizado en tareas y podrán realizarlas como les interese. Al tener
una visión global de todos los proyectos sabrán en cada momento cual es su carga de
trabajo. Podrán cooperar conjuntamente diferentes investigadores a la vez en una tarea.
El IP podrá administrar la contabilidad del proyecto independientemente de la gestión que
realice el PAS. En el caso de que no coincidan las gestiones del PAS con las propias se
podrá buscar rápidamente donde esta el error. Cuando el IP gestione las partidas, podrá
mover el dinero y los gastos donde crea conveniente fácilmente, sin riesgos de errores.
La gestión de la contabilidad permitirá crear divisiones de dinero entre categorías y años.
Al principio de proyecto puede desconocerse las particiones exactas o los años por lo que
al crear el proyecto se podrán definir las particiones. Más adelante se permitirá mover el
dinero de un año a otro y de una categoría a otra, así como añadir, suprimir y modificar
las cantidades.
No es obligatorio gastar el dinero especificado para un año. El dinero no gastado de un
año deberá poder moverse al siguiente año sin dificultad. Deberá llevarse un registro
exhaustivo de los gastos del capital del proyecto. No se registrarán los cambios en
cantidades de dinero pero sí los gastos por persona.
9
En ocasiones los propios investigadores realizan gastos que después les serán abonados
por el proyecto. El tramite del registro de estos gastos y su pago será invisible para el
investigador.
La aplicación permitirá organizar su propio calendario a cada usuario, para que puedan
gestionar los eventos que tengan relación con sus proyectos.
10
3. Diseño
3.1 ¿En que consiste el proyecto?
Se ha estructurado la gestión de la aplicación en cinco partes que se in ter-relacionan entre
ellas: los proyectos, la contabilidad, los usuarios, las tareas y el calendario.
El sistema se compone de las cuatro primeras que son las más importantes.
SISTEMA
CONTABILIDAD
PROYECTO
USUARIO
CONTABILIDAD
PROYECTO
USUARIO
CONTABILIDAD
PROYECTO
USUARIO
TAREA
TAREA
Figura1.Esquema general del sistema
Los usuarios y los proyectos son la base de la aplicación. Los usuarios son las entidades
más importantes ya que no puede existir ningún componente que no tenga asignado al
menos un usuario que sea su responsable.
11
Los usuarios se han dividido en tres tipos de roles posibles según sus responsabilidades y
restricciones de manera jerárquica de más a menos: administrador del sistema,
coordinador del proyecto e investigador.
Administrador
del sistema
Coordinador
del proyecto
Investigador
Figura 2. Esquema jerárquico de los roles de usuario
•
Administrador de sistema: No tiene ninguna restricción de acceso, pueden
acceder a cualquier proyecto o pantalla, y ejecutar cualquier tipo de acción. Sus
permisos estarán a nivel de sistema por encima de los demás roles. Entre otras
cosas sus tareas más importantes serán manejar la entrada y salida de los usuarios
en el sistema así como la organización de sus permisos generales y la creación y
supresión de proyectos.
•
Coordinadores de proyecto: tienen permisos a nivel de proyecto, es decir,
podrán ejecutar cualquier acción que afecte al proyecto del que son coordinadores.
Podrán añadir investigadores a su proyecto y suprimirlos o asignarles tareas y
manejaran la contabilidad de su proyecto. Deberán revisar la contabilidad de sus
proyectos y añadir y suprimir los gastos que vayan haciendo los investigadores
que están a su cargo.
•
Investigadores: los permisos se restringirán a los proyectos a los que pertenecen y
solo podrán consultar los gastos del proyecto pero no modificar-los. Tendrán unas
tareas en las cuales podrán ir añadiendo comentarios con fecha y hora para que sus
coordinadores les puedan hacer un seguimiento si lo necesitan o para que otros
investigadores de su proyecto puedan consultarlo o añadirle información.
12
Los proyectos forman una entidad compuesta con la contabilidad, un proyecto existe si y
solo si existe una contabilidad.
PROYECTO
1
1
CONTABILIDAD
Figura 3. Relación entre proyecto y contabilidad
El proyecto contendrá las relaciones de usuarios, las de tareas y las relaciones entre ellos.
•
Tarea: contendrá dos usuarios, el creador de la tarea (el coordinador de proyecto)
y el investigador asignado a la tarea. El usuario asignado puede ser el mismo
coordinador o podrá cambiar varias veces al largo de la ejecución de la tarea.
La re asignación de las tareas puede deberse a que no tiene conocimientos
suficientes como para poder acabarla y se reasigna a otra persona para que le
ayude y no se quede parada o puede deberse a que el usuario ya no forma parte del
equipo y se deben reasignar sus tareas.
Cada tarea podrá contener varios comentarios en su historial temporal que los
usuarios crean importantes o relevantes para el desarrollo de la misma.
La contabilidad se centrara en la repartición de dinero entre las posibles particiones de
categorías y de años. También contendrá las relaciones entre los gastos, los usuarios y las
categorías.
13
CONTABILIDAD
Partición por Categorías
Partición por Años
Figura 4.Esquema de contabilidad
La parte financiera de los proyectos se estructuraran en categorías y dentro de ellas si es el
caso por años.
CATEGORIA 1
Categoría
1 año 2010
CATEGORIA 2
Categoría
1 año 2011
Categoría
2 año 2011
Categoría
2 año 2012
Nivel
general
Nivel anual
(pertenece a
un año)
Figura 5.Organización de las categorías
•
Categoría: Se podrán definir de dos tipos: generales o anuales. No es obligatorio
tener una partición por años pero si tener al menos una categoría general por
defecto que poder asignar a los gastos de proyecto.
Si hay dinero que no pertenezca a un año en concreto o aun este por definir se
podrá tener en las categorías generales y después si es el caso crear el año y
mover-le el dinero.
Las categorías de los años, obtendrán su parte de dinero de las categorías
generales, no se asignara un dinero concreto a un año, sino a una categoría del
propio año y que será sumado al dinero total del año.
14
Si no están definidas las categorías definitivas inicialmente siempre se podrá crear
una por defecto y luego mover el dinero y borrarla.
CATEGORIA
GASTO
USUARIO
Figura 6. Relación entre categorías, gastos y usuarios
La contabilidad contendrá los diferentes gastos hechos por cada persona.
•
Gasto: Siempre estará relacionado con una persona y una categoría, ya sea dentro
de un año o general y tendrá una fecha concreta de cuando se realizó el gasto.
15
3.2 Estructura MVC
Se ha seguido una estructura muy definida de MVC.
CONTROL
Usuario
VISTA
MODELO
Figura 7.Esquema de MVC
Se ha realizado un diagrama de secuencias de ejemplo para mostrar su funcionamiento.
Figura 8.Diagrama de secuencias
16
1. El administrador quiere realizar una consulta sobre un perfil de usuario y pulsa en el
menú la opción indicada.
2. A continuación se hace la llamada y se le muestra la pagina pidiéndole los datos clave
para poderse-los mostrar.
3. El usuario introduce los datos y se le envían a la parte de control para que realice las
funciones oportunas.
4. El control realiza la petición a la base de datos y esta devuelve el usuario o un mensaje
de error.
3.3 Diagrama Web
Se ha realizado un ejemplo de diagrama web para mostrar en que partes se ha utilizado
JQuery y Ajax y como se han introducido las validaciones de cada formulario:
Figura 9.Diagrama web
17
•
Acciones dinámicas - JQuery y AJAX: Para rellenar listas según los valores de
otros campos se decidió utilizar la técnica de AJAX. El servidor al tratar con
menos información la carga de trabajo es mínima y además evita al usuario tener
que esperar a que se recargue de nuevo toda la página. Así de esta manera se ha
conseguido que también el código sea mucho mas limpio y estructurado.
Se ha utilizado JQuery para ello. Utilizando el ejemplo de la figura se ve como las
jsps de proyectCrear.jsp, usuarioCrear.jsp y usuarioAnadirQuitar.jsp importan
jquery.js y lo utilizaran para aplicar las funciones de validación y funciones
dinámicas de sus otras js.
•
JavaScript - Validaciones: Se ha creado un js de javascript para cada jsp de la
aplicación donde se validan los propios campos. Como que las validaciones de
campos son comunes según si se esperan números, fechas, años…Se ha creado un
js llamado funciones-validation.js que contiene las funciones generales que
utilizan todas los demás js. Estas funciones utilizan también jquery.js para
completar algunas validaciones que son más complejas y necesitan de código java.
18
3.4. Diagrama BD
Figura 10.Diagrama de la BD
19
3.5 Diagrama del flujo de Struts 2
Figura 11.Diagrama del flujo de struts2
•
HttpServletRequest: Realiza la petición al servidor a partir de una petición
http.
Ejemplo:
GET /dumprequest HTTP/1.1
Host: djce.org.uk
Connection: keep-alive
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US)
AppleWebKit/533.4 (KHTML, like Gecko) Chrome/5.0.375.127
Safari/533.4
Referer: http://www.google.es/search?sourceid=chrome&ie=UTF8&q=http+request
Accept:
application/xml,application/xhtml+xml,text/html;q=0.9,text/plain
;q=0.8,image/png,*/*;q=0.5
Accept-Encoding: gzip,deflate,sdch
Accept-Language: es-ES,es;q=0.8
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3
Código 1. Petición de HttpServletRequest
20
•
FilterDispatcher: Redirecciona la petición al Action Proxy.
•
ActionProxy: Realizará la invocación de la acción.
•
Configuration Manager: Proporciona el conjunto de acciones al action proxy
para que pueda invocar la acción pedida.
•
struts.xml:Es el que contiene el conjunto de acciones e interceptores de la
aplicación.
Ejemplo:
<action name="log-action" class="org.gestor.actions.LogAction">
<result name="success" type="redirectAction">
userPrincipal-action</result>
<result name="login-error">
/WEBINF/content/global/loginError.jsp</result>
</action>
Código 2. Definición de un action
•
Action Invocation: Ejecuta los interceptores asociados a la acción y se encarga
de direccionar el resultado de ésta.
•
Interceptores: Conjunto de reglas que se ejecutan antes o después de la llamada
de una acción. Es un sistema flexible y permite ejecutar reglas comunes para
diferentes acciones según los intereses de cada una éstas.
Ejemplo:
<interceptors>
<interceptor-stack name="defaultStack">
<interceptor-ref name="exception"/>
<interceptor-ref name="alias"/>
<interceptor-ref name="servletConfig"/>
<interceptor-ref name="i18n"/>
<interceptor-ref name="prepare"/>
<interceptor-ref name="chain"/>
<interceptor-ref name="debugging"/>
<interceptor-ref name="scopedModelDriven"/>
<interceptor-ref name="modelDriven"/>
<interceptor-ref name="fileUpload"/>
<interceptor-ref name="checkbox"/>
<interceptor-ref name="multiselect"/>
21
<interceptor-ref name="staticParams"/>
<interceptor-ref name="actionMappingParams"/>
<interceptor-ref name="params">
<param name="excludeParams">
dojo\..*,^struts\..*</param>
</interceptor-ref>
<interceptor-ref name="conversionError"/>
<interceptor-ref name="validation">
<param name="excludeMethods">
input,back,cancel,browse</param>
</interceptor-ref>
<interceptor-ref name="workflow">
<param name="excludeMethods">input,back,cancel,
browse, crearProyecto, moverGastos</param>
</interceptor-ref>
</interceptor-stack>
</interceptors>
Código 3. Definición de interceptores
•
Action: Código java que se ejecuta y puede generar un resultado, una
persistencia en base de datos, un fichero, un cálculo, etc...
public class LogAction extends BaseAction{
public LogAction(){
}
public String execute(){
...
return "success";
}
}
Código 4. Clase LogAction.java
•
Result: Según el código ejecutado por el action el flujo se redirigirá a diferentes
resultados que contendrán las diferentes jsps u otras acciones a realizar.
Ejemplo:
<result name="success" type="redirectAction">
userPrincipal-action
</result>
<result name="login-error">
/WEB-INF/content/global/loginError.jsp
</result>
Código 5. Definición de resultados posibles del action
•
Template: Dependiendo del framework que se utilice en la vista, se redirigirá a
una jsp, un fichero de otro framework u otra acción.
22
Ejemplo:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
<title><s:text name="logueo_title"></s:text></title>
<style type="text/css">
@import url("style/styleNew.css");
</style>
</head>
<body>
...
</body>
</html>
Código 6. Definición de una jsp
•
HttpServletResponse: Salida de la petición que contiene el Html final.
Ejemplo:
HTTP/1.0 200 OK
Date: Fri, 31 Dec 1999 23:59:59 GMT
Content-Type: text/html
Content-Length: 1354
<html>
<body>
<h1>Happy New Millennium!</h1>
(more file contents)
...
</body>
</html>
Código 4. Salida de HttpServletResponse
23
3.6 Diagrama de casos de uso
Al ser tan extenso el diagrama de casos de uso, se ha dividido en tres partes según las
acciones que puede hacer cada actor para que sea más fácil de entender.
3.6.1 Casos de uso para el Investigador
Figura 12. Diagrama de casos de uso, rol de investigador
Caso de uso 1. Identificarse
Resumen de funcionalidad: Accede a la aplicación con los permisos asignados a su
usuario.
Caso de uso 2.Consultar calendario
Resumen de funcionalidad: Muestra un calendario donde están señaladas las fechas con
eventos importantes.
Casos de uso relacionados: Modificar evento, Añadir evento, Eliminar evento
Modificar evento: Permite modificar los datos del evento seleccionado.
Añadir evento: Permite añadir un evento al calendario.
Eliminar evento: Permite eliminar el evento seleccionado.
24
Caso de uso 3.Consultar datos personales
Resumen de funcionalidad: Muestra los datos personales del usuario registrados en el
sistema
Casos de uso relacionados: Modificar datos personales
Modificar datos personales: Permite modificar los datos del usuario logueado.
Caso de uso 4.Consultar tarea
Resumen de funcionalidad: Permite al investigador acceder a una tarea desde un buscador
según diversos criterios de búsqueda como el código de identificación de la tarea, su
usuario asignado, sus fechas iniciales y finales, su estado…
Casos de uso relacionados: Modificar tarea, 10.Eliminar tarea
Modificar tarea: Permite modificar los datos de la tarea seleccionada
25
3.6.2 Casos de uso para el Coordinador
Figura 13. Diagrama de casos de uso, rol de coordinador
Caso de uso 5.Consultar gasto
Resumen de funcionalidad: Permite acceder a los datos de un gasto buscándolo por
diferentes criterios de búsqueda como el código de identificación del gasto, el usuario, la
fecha…
Casos de uso relacionados: 6.Modificar gasto, 7.Eliminar gasto
Caso de uso 6.Modificar gasto
Resumen de funcionalidad: Permite al coordinador modificar los datos del gasto
seleccionado
26
Casos de uso relacionados: 3.Consultar gasto
Caso de uso 7. Eliminar gasto
Resumen de funcionalidad: Permite al coordinador eliminar un gasto seleccionado de su
proyecto. El dinero del gasto se volverá a añadir al dinero no utilizado del proyecto.
Casos de uso relacionados: 3.Consultar gasto
Caso de uso 8.Crear gasto
Resumen de funcionalidad: Permite al coordinador añadir un gasto a su proyecto. Se
puede seleccionar una categoría general o una categoría dentro de un año donde añadirlo.
Caso de uso 9.Crear tarea
Resumen de funcionalidad: El coordinador puede crear una tarea nueva en su proyecto y
asignarla a cualquier usuario que pertenezca al mismo.
Caso de uso 10. Eliminar tarea
Resumen de funcionalidad: Permite al coordinador eliminar la tarea seleccionada.
Casos de uso relacionados: 2.Consultar tarea
Caso de uso 11.Modificar permisos usuario
Resumen de funcionalidad: El coordinador de proyectos puede modificar los permisos de
todos los usuarios que pertenezcan a su proyecto. Puede seleccionar entre “administrador”
y “usuario”.
Caso de uso 12. Añadir usuario al proyecto
Resumen de funcionalidad: El coordinador puede añadir usuarios que participaran en ese
proyecto. Al añadirlos podrá escoger entre darles permisos de investigador o de
coordinador.
Casos de uso relacionados: 2.Consultar tarea
Caso de uso 13. Eliminar usuario del proyecto
27
Resumen de funcionalidad: El coordinador puede dar de baja la participación de un
usuario del proyecto donde es responsable. Se reasignaran las tareas de esa persona.
Casos de uso relacionados: 2.Consultar tarea
Caso de uso 14.Consultar proyecto
Resumen de funcionalidad: Muestra los datos generales del proyecto como la fecha, el
nombre, el coordinador...
Casos de uso relacionados: Modificar datos del proyecto.
Modificar datos del proyecto: Permite al coordinador modificar los datos
generales del proyecto, asignarle otro coordinador, cambiar el objetivo del
proyecto.
Caso de uso 15.Consultar contabilidad
Resumen de funcionalidad: Muestra los datos generales de la contabilidad como la
entidad bancaria, el dinero total del proyecto, las particiones...
Casos de uso relacionados: Modificar datos de la contabilidad, Modificar partición
categorías, Modificar partición años.
Modificar datos de la contabilidad: Permite al coordinador modificar los datos
generales del proyecto y de la contabilidad. Puede realizar particiones de año y
de categorías y mover el dinero de una partición a otra.
Modificar partición categorías: Puede crear nuevas categorías donde clasificar
los gastos del proyecto y mover el dinero de una partición a otra.
Modificar partición años: Puede asignar años al proyecto donde se clasificaran
los gastos del proyecto y mover el dinero de un año a otro.
28
3.6.3 Casos de uso para el Administrador
Figura14. Diagrama de casos de uso, rol de administrador
Caso de uso 16. Añadir usuario al sistema
Resumen de funcionalidad: El administrador puede añadir nuevas personas al sistema que
serán asignados a proyectos en el momento o más adelante por coordinadores o por el
propio administrador. Los usuarios se pueden crear no activos y activar más adelante para
su uso.
Caso de uso 14. Consultar perfil usuario del sistema
Resumen de funcionalidad: El administrador del sistema puede consultar cualquier perfil
de usuario del sistema.
Casos de uso relacionados: Modificar perfil de usuario, Eliminar usuario
Modificar perfil de usuario del sistema: El administrador puede modificar los
datos personales de cualquier persona del sistema, asi como su usuario y
contraseña.
Eliminar usuario del sistema: El administrador puede eliminar cualquier
persona del sistema.
29
Caso de uso 18. Crear proyecto
Resumen de funcionalidad: El administrador puede crear un proyecto y su contabilidad.
Puede conocerse desde el inicio las particiones por años y por categorías que tendrá la
contabilidad y crearse completamente o pueden desconocerse y modificarse mas adelante.
Caso de uso 19.Eliminar proyecto
Resumen de funcionalidad: El administrador del sistema puede eliminar un proyecto del
sistema. Se borrarán todas las dependencias con los gastos, los usuarios y las tareas que
estos tengan asignadas así como su contabilidad.
30
3.7. Decisiones de diseño
3.7.1. Tipos de calendario
Para decidirme estuve mirando y comparando varios tipos de calendarios pero finalmente
probé tres en particular que fueron: jQuery UI Datepicker, JSCalendar y FullCalendar.
•
JQuery Ui Datepicker
Figura 15. Calendario de Jquery Ui Datepicker
http://jqueryui.com/demos/datepicker/#inline
31
•
JSCalendar
Figura 16. Calendario de JSCalendar
http://www.dynarch.com/projects/calendar/
•
Full Calendar
Figura 17. Calendario Full Calendar
http://arshaw.com/fullcalendar/
32
He agrupado las características importantes que puede tener un calendario y los he
comparado entre sí para ver las diferencias:
Características
JSCalendar
JQuery Ui
Full Calendar
Datepicker
- Agradables a la vista
-Estructura modificable
-Visión de eventos de varios
meses a la vez
-Visión de eventos por semana
-Visión de eventos por día
-Permite arrastrar los eventos a
otro día/hora y alargar el tiempo.
-Añadir
un
evento
dinámicamente.
-Muestra la hora actual
Tabla 1.Comparación de características de los calendarios
3.7.2. JQuery
La carga de listas dinámicas enlazadas se ha realizado por JavaScript y JQuery para
liberar al servidor de una carga de peticiones excesiva y proporcionar una mejor
experiencia de usuario.
Además por problemas mencionados en el apartado siguiente 4.1 Problemas encontrados
durante la fase de implementación se decidió también realizar las validaciones de
formularios.
33
4. Desarrollo
Para el proceso de desarrollo del software se ha seguido un modelo cascada re alimentado
para el ciclo de vida.
Figura 18. Esquema del ciclo de vida
Que consiste en las siguientes etapas:
•
Primera etapa: Se especificaron los requisitos de la aplicación (la contabilidad se
dividirá en categorías y en años…)
•
Segunda etapa: Se empezó con el diseño del sistema, la estructura general del
diseño como se distribuiría. Se reajustaron los requisitos mientras se diseñaba.
(Aquí empezamos a utilizar la re alimentación del sistema)
•
Tercera etapa: Implementamos las bases de la aplicación, las funciones y
realizamos sus correspondientes pruebas unitarias. Durante el proceso volvemos a
al paso anterior a al primero.
•
Cuarta etapa: Se siguen los pasos indicados en las anteriores, pero esta vez se
hacen las pruebas con datos reales en las versiones finales de la aplicación. Se
resuelven problemas y se definen los últimos detalles del sistema.
34
•
Quinta etapa: Se realiza el mantenimiento de la aplicación por si surgen errores.
4.1 Problemas encontrados durante la fase de implementación
•
Validadores de Struts2: Se decidió implementar las validaciones de los
formularios con struts2. Esta nueva versión de struts tiene unos validadores muy
potentes de formularios y después de hacer unas cuantas pruebas de cada tipo en
una .jsp aparte intente aplicarlo en el proyecto. No hacia ninguna validación de
ningún tipo que estuviera en el paquete de struts.xml con hibernate. Esto era
debido a los interceptores que tiene hibernate, que deshabilitaban esos validadores.
Después de probar muchos interceptores diferentes se decidió optar por las
validaciones por JavaScript y JQuery ya que los otros interceptores interferían con
la BD y no permitían conectarla.
•
Excepciones genéricas: Como que las páginas web pueden perder la conexión o
caducar, pensé en poner una página de error que capturase la excepción desde
cualquier página donde estuviese el usuario y lo redirigiera a la página de logueo.
Para poder hacerlo se tiene que poner el interceptor <default-interceptor-ref
name="defaultStack"/> para poder capturar las excepciones y el error que se
quiere capturar se pone con la etiqueta <global-exception-mappings> y dentro de
esta
con
<exception-mapping
exception="java.lang.Exception"
result="transaccion-error"/>.
•
Id's compuestas dan error Long: Las clases de la base de datos que contienen
id's compuestas por dos entidades o más, al crear los Beans en java de la bd
pueden dar el error “ORA-01461: can bind a LONG value only for insert into a LONG
column”. Esto es debido a que cuando se generan las claves primarias se generan
como otra nueva clase java llamada Bean_PK.
La Base de datos espera un único valor para cada entidad compuesta o un String o
un valor numérico pero si se intentan insertar como entidades, la base de datos no
los identifica como tales y da el error. Para solucionarlo se cambiaron los Beans
que habían en la clave primaria por la id de cada entidad.
35
5. Evaluación
5.1. Pruebas
Se ha utilizado JUnit para evaluar la parte funcional y Selenium para realizar las pruebas
sobre la interfície gráfica.
5.1.1. JUnit
Para la parte funcional sobre J2EE se han creado una serie de test que evalúan todas las
operaciones existentes de la aplicación sin modificar ni dañar la BD o sus datos.
Para ello primero evaluaremos las operaciones de creación y pondremos valores de
prueba a los objetos que utilizaremos para los test. Después manipularemos esos objetos
al ejecutar todas las operaciones de modificación y re asignación y por último
ejecutaremos las operaciones de supresión para volver a tener la BD intacta como al inicio
de los test.
Figura 19. Test de creación de objetos verificado
36
Figura 20. Test de modificación de gasto fallido
5.1.2. Selenium
Para la parte visual se han realizado pruebas sobre la interfície gráfica que se han ido
grabando en el programa Selenium como tests de usabilidad web.
Algunas acciones como las búsquedas de datos, usuarios o modificaciones de dinero han
sido más fáciles de realizar que otras como las creaciones que se han tenido que validar
muchas variables.
Figura 21.Test de loguear-se verificado
Figura 22. Test de loguear-se fallido
37
5.2. Mejoras y limitaciones
5.2.1. Gráficos y tablas
•
Los datos de la contabilidad son muy poco visuales, las extracciones numéricas
son más detalladas pero si el usuario solo quiere mirar por encima a grandes
rasgos los gastos económicos, le irían mejor unos gráficos de barras o de
porciones para ver a simple vista cuánto dinero queda de cada tipo por gastar.
12
10
8
Total
6
Gastado
Restante
4
2
0
Categoria A Categoria B Categoria C
Figura 23. Gráfico de los datos de la contabilidad
•
Las tareas también podrían mostrar-se con gráficos para que el coordinador
supiera cuantas están en proceso o cuantas cerradas.
Abiertas
Pendientes
Cerradas
Paradas
Figura 24. Gráfico
de los estados de las tareas
38
5.2.2. Calendario de proyecto
•
Calendario, aparte del calendario de usuario, crear uno generico para que los
eventos generales se compartieran entre los diferentes componentes del equipo.
•
Invitaciones de eventos, entre los compañeros de proyecto se pudieran enviar
invitaciones con eventos de conferencias por si les pudiera interesar.
5.2.3. Tarea
•
Historial de movimientos, mostrar un historial con los diferentes movimientos
que realizan los usuarios en la tarea por orden cronológico.
•
Tiempo en la tarea, crear unos gráficos para mostrar el tiempo empleado en la
tarea y el restante. Esto mejoraría la percepción del tiempo que se esta empleando
al coordinador de proyecto y podría ver si se necesita más apoyo con la tarea
indicada o podría añadirse-le más funcionalidades.
5.2.4. Estructura interna
•
Renovar estructura, la estructura del proyecto es correcta, pero si crece, estaría
mejor incorporar algunos componentes para diferenciar más las capas del modelo
MVC.
Estos objetos serían:
◦ Forms: Objetos relacionados con el Action, los dtos y la jsp. Contendrán los
datos del formulario.
◦ DTOs: (Data object) objetos utilizados para la presentación de los datos en
pantalla y su recogida. Son los que se utilizarian para manipular los datos de la
presentación.
◦ Business Components: Objetos que relacionan el Action y los DAOs. Toda la
parte de negocio la realizan ellos de manera que el action solo debe llamarlos e
indicarle lo que necesita que hagan.
39
Figura 25. Estructura interna del proyecto
Actualmente la capa de control esta repartida entre los Actions y los daos, en la nueva
estructura esto cambiaría y se encargarían los business.
•
Métodos genéricos: crear una interfaz de métodos genéricos para todos los daos
para que no se tuvieran que implementar algunos básicos para cada DAO, por
ejemplo buscar un objeto por su id en la BD.
•
Incorporar tiles: Tiles es una tecnología que se utiliza para poder organizar los
diferentes componentes en la presentación. Puede crear patrones de presentación
genéricos para que diferentes pantallas puedan heredar y facilita la modificación
de estas cuando hay muchas.
40
5.2.5. Framework
Aunque la tecnologia de struts presenta muchas ventajas también tiene limitaciones. Es
bastante lenta a la hora de hacer las llamadas a la capa de control. Por ello se podría
cambiar por otro framework o añadirle algunas tecnologias para mejorarlo.
•
Capa de control: Podría combinarse struts y spring para la capa de control.
•
Frameworks: Algunas alternativas serían Wicket, JSF y J2EE.
◦ Wicket: presenta muchas ventajas en la capa de control, pero al ser un
framework reciente, tiene muy poca documentación y se deberia investigar
mucho antes de aprenderlo.
◦ Jsf: es el estandard de java, presenta mucha variedad de opciones a la hora de
implementar.
◦ J2EE: se tendría que construir el flujo de procesos como llamar a las acciones.
Podría llegar a ser contraproducente porque se debería invertir mucho tiempo.
5.2.6. Exploradores de Internet
Se decidió usar CSS2 para el diseño visual de la aplicación, pero todos los exploradores
de Internet excepto Chrome no implementan el estándar de la W3C en su totalidad.
Hay diferencias visibles entre ejecutarlo en Internet Explorer, Mozilla Firefox y Chrome
por ello se ha realizado el test de Acid3 en cada uno para poner a prueba estos
navegadores con los estándares web. En este test se realizan pruebas sobre tecnologías
Web 2.0 y algunas sub-pruebas se encargan del lenguaje SVG, XML y del esquema
data:URI.
41
•
Chrome dio la máxima puntuación en la versión 4 y fue el único en superar la
prueba de los 3 navegadores:
Figura 26. Test de Acid3 en Chrome
•
Mozilla Firefox en la versión 3.5.9 no llego a superar del todo la prueba:
42
Figura 27. Test de Acid3 en Mozilla Firefox
•
Internet Explorer 7 no supero la prueba:
Figura 28. Test de Acid3 en Internet Explorer 7
43
6. Conclusiones
He aprendido a utilizar diversas tecnologías y a unificarlas en un mismo proyecto que era
lo que me interesaba aprender de esta experiencia.
JavaScript y AJAX junto con JQuery ha sido una de las cosas que más me ha sorprendido
porque me pensaba que me costaría utilizar y me ha resultado más sencillo de lo que creía
en un principio y mucho más útil. En la parte web es donde he aprendido más, tecnologías
como Struts2 y el multiidioma que me parecían más fáciles me han dado muchos más
problemas sobre todo por los interceptores en la configuración. Como era la primera vez
que utilizaba estas tecnologías he perdido mucho tiempo al inicio del proyecto antes de
adaptarme a ellas y he tenido que rehacer varias estructuras.
Css2 para el diseño de la parte visual de la página web me ha resultado todo un reto.
Quería hacer un diseño simple, navegable y agradable a la vista y aunque creo que se
podría mejorar estoy satisfecha con el resultado final.
6.1. Motivaciones
En una formación que realice al entrar en la empresa donde trabajo me enseñaron el
framework de Struts 1 junto con otros muy por encima. Aunque me pareció muy
interesante no he tenido la oportunidad aun de trabajar con él en un proyecto. He
trabajado con varios proyectos pero no he tocado mucha web y tenía mucho interés en
aprender sobre ello. Por lo que me propuse realizar una aplicación para aprender a
manejarlo y mientras iba avanzando descubrí más tecnologías interesantes que podría
aprovechar para aplicar como por ejemplo JQuery. Había leído sobre la técnica de Ajax
pero aun no había tenido la ocasión de realizar ningún ejemplo yo misma, por lo que
cuando se me planteó la oportunidad decidí intentarlo.
44
7. Recursos utilizados
7.1. Tecnologías utilizadas
J2SE:
Java Platform, Standard Edition o Java SE (conocido anteriormente hasta la
versión 5.0 como Plataforma Java 2, Standard Edition o J2SE), es una
colección de APIs del lenguaje de programación Java útiles para muchos
programas de la Plataforma Java. La Plataforma Java 2, Enterprise Edition
incluye todas las clases en el Java SE, además de algunas de las cuales son útiles para
programas que se ejecutan en servidores sobre workstations.
Comenzando con la versión J2SE 1.4 (Merlin), la plataforma Java SE ha sido desarrollada
bajo la supervisión del Java Community Process. JSR 59 la especificación para J2SE 1.4
y JSR 176 especificó J2SE 5.0 (Tiger). En 2006, Java SE 6 (Mustang) está siendo
desarrollada bajo el JSR 270.
J2EE:
Es una plataforma de programación (parte de la Plataforma Java) para desarrollar y
ejecutar software de aplicaciones en Lenguaje de programación Java con arquitectura de
N niveles distribuida, basándose ampliamente en componentes de software modulares
ejecutándose sobre un servidor de aplicaciones.
La plataforma Java EE está definida por una especificación. Similar a otras
especificaciones del Java Community Process, Java EE es también considerada
informalmente como un estándar debido a que los suministradores deben cumplir ciertos
requisitos de conformidad para declarar que sus productos son conformes a Java EE;
estandarizado por The Java Community Process / JCP.
Java EE incluye varias especificaciones de API, tales como JDBC, RMI, e-mail, JMS,
Servicios Web, XML, etc y define cómo coordinarlos. Java EE también configura algunas
45
especificaciones únicas para Java EE para componentes. Estas incluyen Enterprise
JavaBeans, servlets, portlets (siguiendo la especificación de Portlets Java), JavaServer
Pages y varias tecnologías de servicios web. Esto permite al desarrollador crear una
Aplicación de Empresa portable entre plataformas y escalable, a la vez que integrable con
tecnologías anteriores. Otros beneficios añadidos son, por ejemplo, que el servidor de
aplicaciones puede manejar transacciones, la seguridad, escalabilidad, concurrencia y
gestión de los componentes desplegados, significando que los desarrolladores pueden
concentrarse más en la lógica de negocio de los componentes en lugar de en tareas de
mantenimiento de bajo nivel.
Oracle database server:
Es una herramienta cliente/servidor para la gestión de Bases de Datos. Se considera uno
de los sistemas de bases de datos más completos, destacando su soporte de transacciones,
su estabilidad, su escalabilidad y su soporte multiplataforma.
Ha sido criticada por algunos especialistas la seguridad de la plataforma, y las políticas de
suministro de parches de seguridad, modificadas a comienzos de 2005 y que incrementan
el nivel de exposición de los usuarios. En los parches de actualización provistos durante el
primer semestre de 2005 fueron corregidas 22 vulnerabilidades públicamente conocidas,
algunas de ellas con una antigüedad de más de 2 años.
Aunque su dominio en el mercado de servidores empresariales ha sido casi total hasta
hace poco, recientemente sufre la competencia del Microsoft SQL Server de Microsoft y
de la oferta de otros RDBMS con licencia libre como PostgreSQL, MySql o Firebird. Las
últimas versiones de Oracle han sido certificadas para poder trabajar bajo GNU/Linux.
46
Hibernate:
Es una herramienta de mapeo objeto-relacional
para la plataforma Java que permite relacionar la aplicación Java con la Base de datos de
la propia aplicación y facilita el mapeo de atributos entre una base de datos relacional y el
modelo de objetos de una aplicación, mediante archivos declarativos (XML) que permiten
establecer estas relaciones.
Como todas las herramientas de su tipo, Hibernate busca solucionar el problema de la
diferencia entre los dos modelos de datos coexistentes en una aplicación: el usado en la
memoria de la computadora (orientación a objetos) y el usado en las bases de datos
(modelo relacional). Para lograr esto permite al desarrollador detallar cómo es su modelo
de datos, qué relaciones existen y qué forma tienen. Con esta información Hibernate le
permite a la aplicación manipular los datos de la base operando sobre objetos, con todas
las características de la POO. Hibernate convertirá los datos entre los tipos utilizados por
Java y los definidos por SQL. Hibernate genera las sentencias SQL y libera al
desarrollador del manejo manual de los datos que resultan de la ejecución de dichas
sentencias, manteniendo la portabilidad entre todos los motores de bases de datos con un
ligero incremento en el tiempo de ejecución.
Hibernate está diseñado para ser flexible en cuanto al esquema de tablas utilizado, para
poder adaptarse a su uso sobre una base de datos ya existente. También tiene la
funcionalidad de crear la base de datos a partir de la información disponible.
•
Hibernate tools: Es una herramienta de Jboss para el soporte de mapeos
de archivos, anotaciones y JPA con ingeniería inversa, refactorización y
ejecución de HQL/APP-QL/Criteria. Es una fusión entre las herramientas de
hibernate y características de Exadel ORM.
JDBC:
47
Java Database Connectivity es una api que permite la ejecución de operaciones sobre
bases de datos desde el lenguaje de programación Java, independientemente del sistema
operativo donde se ejecute o de la base de datos a la cual se accede, utilizando el dialecto
SQL del modelo de base de datos que se utilice.
El API JDBC se presenta como una colección de interfaces Java y métodos de gestión de
manejadores de conexión hacia cada modelo específico de base de datos. Un manejador
de conexiones hacia un modelo de base de datos en particular es un conjunto de clases
que implementan las interfaces Java y que utilizan los métodos de registro para declarar
los tipos de localizadores a base de datos (URL) que pueden manejar. Para utilizar una
base de datos particular, el usuario ejecuta su programa junto con la biblioteca de
conexión apropiada al modelo de su base de datos, y accede a ella estableciendo una
conexión, para ello provee el localizador a la base de datos y los parámetros de conexión
específicos. A partir de allí puede realizar con cualquier tipo de tareas con la base de datos
a las que tenga permiso: consulta, actualización, creación, modificación y borrado de
tablas, ejecución de procedimientos almacenados en la base de datos, etc.
JQuery:
JQuery es un framework en JavaScript que ofrece una serie de funcionalidades basadas en
JavaScript para ayudar a interactuar de manera mucho más simple y limpia con
documentos HTML, ayuda a manejar eventos, a desarrollar animaciones y agregar
interacción con la tecnología AJAX a páginas web de manera más eficiente.
jQuery consiste en un único fichero JavaScript que contiene las funcionalidades comunes
de DOM, eventos, efectos y AJAX.
La característica principal de la biblioteca es que permite cambiar el contenido de una
página web sin necesidad de recargarla, mediante la manipulación del árbol DOM y
peticiones AJAX. Para ello utiliza las funciones $() o jQuery().
48
jQuery es software libre y de código abierto, posee un doble licenciamiento bajo la
licencia MIT y de la GNU General Public License, Versión 2.
AJAX:
Acrónimo de Asynchronous JavaScript
And XML, es una técnica web para crear aplicaciones interactivas. Permite que se realicen
cambios en páginas web de manera más rápida e interactiva al evitar que tengan que
volver a recargarse completamente.
Esto se consigue porque las aplicaciones se ejecutan en el navegador de los propios
usuarios (la parte de cliente) mientas mantienen la comunicación asíncrona con el
servidor en segundo plano.
Struts 2:
Es una herramienta de soporte para el desarrollo de
aplicaciones Web bajo el patrón MVC bajo la
plataforma J2EE. Struts permite reducir el tiempo de
desarrollo y en la versión 2 (la que se ha utilizado)
se han introducido algunas mejoras como su
integración con AJAX.
Struts se basa en el framework MVC (Modelo Vista Controlador) y se separa en tres
secciones bien diferenciadas que son el modelo, las vistas y el controlador.
El modelo es donde están los objetos, las vistas la parte visible al cliente y el controlador
será la parte funcional de todo el sistema.
49
Servidor Tomcat:
Es un servidor web con soporte de servlets y
JSPs. Incluye el compilador Jasper que
compila JSPs convirtiendolas en servlets. El servlet de tomcat a menudo se presenta en
combinación con el servidor web Apache.
Tomcat puede funcionar como servidor web por sí mismo. En sus inicios existió la
percepción de que el uso de Tomcat de forma autónoma era sólo recomendable para
entornos de desarrollo y entornos con requisitos mínimos de velocidad y gestión de
transacciones. Hoy en día ya no existe esa percepción y Tomcat es usado como servidor
web autónomo en entornos con alto nivel de tráfico y alta disponibilidad.
Dado que Tomcat fue escrito en Java, funciona en cualquier sistema operativo que
disponga de la máquina virtual Java.
Se ha utilizado un servidor HTTP Apache:
El servidor HTTP Apache es un servidor web HTTP de código abierto para plataformas
Unix (BSD, GNU/Linux, etc.), Microsoft Windows, Macintosh y otras, que implementa
el protocolo HTTP/1.11 y la noción de sitio virtual. Cuando comenzó su desarrollo en
1995 se basó inicialmente en código del popular NCSA HTTPd 1.3, pero más tarde fue
reescrito por completo. Su nombre se debe a que Behelendorf quería que tuviese la
connotación de algo que es firme y enérgico pero no agresivo, y la tribu Apache fue la
última en rendirse al que pronto se convertiría en gobierno de EEUU, y en esos momentos
la preocupación de su grupo era que llegasen las empresas y "civilizasen" el paisaje que
habían creado los primeros ingenieros de internet. Además Apache consistía solamente en
un conjunto de parches a aplicar al servidor de NCSA. Era, en inglés, a patchy server (un
servidor "parcheado").
El servidor Apache se desarrolla dentro del proyecto HTTP Server (http) de la Apache
Software Foundation.
50
JUnit:
Es un conjunto de herramientas que permite realizar la ejecución
de clases java para poder evaluar el funcionamiento de cada uno de los métodos de la
aplicación de manera controlada.
Al final de cada test se añade una condición que evaluara si el resultado obtenido es el
esperado o no.
Se ha utilizado Junit y su plug-in para eclipse para evaluar las funcionalidades de toda la
aplicación.
Selenium:
Selenium es un conjunto de herramientas que sirve para
poder automatizar las pruebas de aplicaciones web a través
de muchas plataformas.
Proporciona una herramienta de grabación y reproducción
para ejecutar pruebas sin tener que aprender un lenguaje de
test aparte.
Selenium proporciona un dominio de lenguaje específico (DSL) para poder escribir test
en un gran número de lenguajes diferentes incluido Java, Ruby, Groovy, Pitón, PHP y
Perl. También permite deployar en las plataformar de Windows, Linux y Macintosh.
Se ha utilizado Selenium para testear la parte web de la aplicación.
Eclipse GALILEO:
Eclipse es un entorno de desarrollo integrado de código
abierto multiplataforma para desarrollar lo que el proyecto
llama "Aplicaciones de Cliente Enriquecido", opuesto a las
51
aplicaciones "Cliente-liviano" basadas en navegadores. Esta plataforma, típicamente ha
sido usada para desarrollar entornos de desarrollo integrados (del inglés IDE), como el
IDE de Java llamado Java Development Toolkit (JDT) y el compilador (ECJ) que se
entrega como parte de Eclipse (y que son usados también para desarrollar el mismo
Eclipse). Sin embargo, también se puede usar para otros tipos de aplicaciones cliente,
como BitTorrent Azureus.
Eclipse es también una comunidad de usuarios, extendiendo constantemente las áreas de
aplicación cubiertas. Un ejemplo es el recientemente creado Eclipse Modeling Project,
cubriendo casi todas las áreas de Model Driven Engineering.
Eclipse fue desarrollado originalmente por IBM como el sucesor de su familia de
herramientas para VisualAge. Eclipse es ahora desarrollado por la Fundación Eclipse, una
organización independiente sin ánimo de lucro que fomenta una comunidad de código
abierto y un conjunto de productos complementarios, capacidades y servicios.
Eclipse dispone de un Editor de texto con resaltado de sintaxis. La compilación es en
tiempo real. Tiene pruebas unitarias con JUnit, control de versiones con CVS, integración
con Ant, asistentes (wizards) para creación de proyectos, clases, tests, etc., y
refactorización.
Asimismo, a través de "plugins" libremente disponibles es posible añadir control de
versiones con Subversion e integración con Hibernate.
Magic Draw UML 16.0:
Es una herramienta de desarrollo
de para crear a UML. La herramienta que soporta UML 2.1.2, múltiples lenguajes de
programación (Java, C++, C# y otros) así como modelos de datos. La herramienta tiene
unas facilidades y soportes integrados en los IDEs.
52
SqlDeveloper:
Oracle SQL Developer es una herramienta grafica para el desarrollo de bases
de datos gratuita y con soporte total por parte de Oracle. Con SQL Developer,
se puede navegar entre los objetos de la base de datos, ejecutar sentencias y
scripts de SQL y editar y debuggar sentencias PL/SQL.
Controlador de versiones Unfuddle:
Es una herramienta de gestión de versiones de
proyectos para equipos de desarrollo de software.
7.2 Programas auxiliares
Traducir ficheros de idiomas:
Se ha usado una api de google que hace traducciones de archivos para poder obtener
otros ficheros de idiomas al ejecutarlo en el formato que se necesita.
Escoger fecha en calendario:
Para los campos de fechas en los formularios se ha utilizado un script auxiliar que permite
crear un pequeño calendario para poder escoger la fecha y colocarla en un formato
determinado.
Se han añadido algunos métodos para completar este script que ayuda a evitar
información introducida incorrectamente por parte del usuario a la hora de validar.
53
7.3. Bibliografía
7.3.1. Páginas web
Web oficial de Selenium
http://seleniumhq.org/
Web oficial de JQuery
http://jquery.com/
Web oficial de Oracle
http://www.oracle.com/
Web Subversion
http://unfuddle.com/
Web oficial de Magic Draw
http://www.magicdraw.com/
Tipos de calendarios
http://www.elwebmaster.com/articulos/jquery-9-plugins-para-crear-calendarios-yseleccionadores-de-fecha
7.3.2. Libros
Struts 2 in Action
Donald Brown, Chad Michael Davis, and Scott Stanlick
ISBN: 193398807X
54
8. Manuales
8.1. Instalación del entorno y configuración
8.1.1. Entorno de desarrollo
El entorno de desarrollo está enfocado a que los cambios que van surgiendo durante la
fase de programación tengan un impacto mínimo en el servidor de manera que se puedan
efectuar test unitarios y pruebas del aplicativo.
Para empezar se ha de tener instalada la versión 1.6 de Java en el ordenador. Se puede
bajar de la pagina “http://www.java.com/es/download/”.
Figura 29. Página de descarga de JAVA
Se
ha
de
descargar
el
servidor
web
Tomcat
6.0
de
la
pagina
web
http://tomcat.apache.org/download-60.cgi. Se puede descargar cualquier instalación del
Core.
55
Figura 30. Página de descarga de Tomcat
El programa que se ha elegido para poder desarrollar es el Eclipse Galileo que se puede
descargar desde “http://www.eclipse.org/downloads/”
Figura 31. Página de descarga de eclipse
Solo faltara instalar el entorno para poder gestionar la BD, para ello necesitaremos
instalar el servidor para la BD.
Se puede bajar desde http://www.oracle.com/technology/software/index.html.
56
Figura 32. Página de descarga de Oracle
Una vez instalado todo lo necesario ya se podrá empezar a configurar el entorno.
Para poder bajarnos la última versión del código de la aplicación del subversión se deberá
configurar la SVN.
Abriremos la perspectiva del eclipse de la SVN
Figura 33. Configurando la SVN
57
Y clicaremos en la opción Repository location donde pondremos a descargar el
repositorio con la url de unfuddle
Figura 34. Añadiendo el repositorio a eclipse
Cuando finalicemos haremos un Checkout del proyecto que nos aparecerá y el eclipse
descargara los archivos.
58
Figura 35. Descargando el proyecto desde el repositorio
Ahora que tenemos el proyecto bajado, configuraremos la conexión con la BD.
En mi caso he utilizado un Oracle 10g pero en otros servidores diferentes se podrían
utilizar otros como mySQL, postgreSQL, DB2…
Lo que hay que modificar en función del tipo de servidor y dónde esté ubicado seria en las
propiedades del archivo hibernate.cfg.xml.
“hibernate.connection.url” para especificarle donde está el servidor de la BD y
“hibernate.connection.driver_class” y “hibernate.dialect” para el tipo de BD especificado
en la documentación de la BD de hibernate.
Figura 36. Fichero de configurando de hibernate
59
Configuraremos el servidor del tomcat para poder lanzarlo.
Haremos clic derecho en la perspectiva del servidor y pondremos NewServer:
Figura 37. Añadiendo el servidor Tomcat
Seleccionamos el Tomcat 6.0, indicamos su ubicación y finalizamos.
60
Para finalizar añadimos el proyecto con la opción de Add and remove y podremos lanzar
la aplicación en desarrollo.
Figura 38. Añadiendo el proyecto al servidor
61
8.1.2. Entorno de producción
El entorno de producción está enfocado al uso diario 24 horas del aplicativo para que
varios usuarios puedan acceder a él paralelamente sin que suponga un esfuerzo excesivo
para el servidor.
Exportaremos el proyecto en un .war ExportWAR file.
Figura 39. Exportación del war del proyecto
Lo ubicaremos en la carpeta donde esté instalado el servidor Tomcat 6.0 dentro de la
carpeta webapps.
Para poder ejecutar la aplicación necesitamos tener definidas en el ordenador 2 variables
del sistema CATALINA_HOME y JAVA_HOME. Podremos añadirlas en Panel de
ControlSistemaPestaña de Opciones avanzadasVariables de entorno
62
Figura 40. Añadiendo las variables de entorno
CATALINA_HOME deberá contener la ruta de la carpeta donde está el servidor de
apache y JAVA_HOME deberá contener la ruta de java.
Acabado esto faltará configurar el servidor. Para ello abriremos el archivo server.xml de
la carpeta (Instalación de Apache 6.0)/conf/server.xml y buscaremos el puerto que
utilizará para asegurarnos que está abierto y libre. Por defecto viene el 8080.
Figura 41. Configuración del servidor
Después faltará comprobar que las variables unpackWARs y autoDeploy están a true.
UnpackWARs sirve para que el servidor encuentre el .war donde hemos exportado la
63
aplicación y lo descomprima en una carpeta y el autoDeploy servirá para que el servidor
pueda recargar los cambios que se le efectúen al código de la carpeta y los actualice.
Figura 42. Configurando el autodeploy del server
Ahora podremos lanzar la aplicación desde cualquier ordenador poniendo el nombre de la
maquina seguido de /GestorProyectosPFC:
Figura 43. Pantalla
inicial de la aplicación
64
8.1.3. Entorno de usuario
Solo harán falta los exploradores que soporten los estándares de la W3C en relación al
HTML 4.01 Transitional especificado en http://www.w3.org/TR/html4/loose.dtd y CSS2
especificado en http://www.w3.org/TR/CSS2/.
8.2. Manual de usuario
Figura 44. Pantalla de acceso
Figura 45. Pantalla principal de administrador
65
Figura 46. Pantalla principal de usuario
13.1.1. Proyecto
13.1.1.a. Crear un proyecto:
•
Loguearse con los permisos de administrador.
•
Menú de la izquierda en la sección de “Proyecto” pulsar en la opción “Crear
proyecto”. Se abrirá una nueva pestaña.
Figura 47. Pantalla crear proyecto
66
•
Rellenar los campos y pulsar en “Crear”. Los campos indicados en color
amarillo son obligatorios.
•
Cuando se cree el proyecto se mostraran las opciones de crear partición por años
y por categorías opcionales.
Figura 48. Pantalla crear proyecto, botones para crear particiones
◦ Si no se crea ninguna se definirán unas por defecto y se podrán modificar
más adelante.
◦ Se escoge crear partición por año (Ver punto 13.1.5.c. Modificar partición
años)
◦ Se escoge crear partición por categoría ir al punto (Ver punto 13.1.5.b.
Modificar partición categorías)
•
Pulsar en cancelar para cerrar la pestaña y volver a la pantalla principal.
13.1.1.b. Eliminar un proyecto:
•
Loguearse con los permisos de administrador.
•
Menú superior seleccionar “Proyecto” y pulsar en la opción “Eliminar
proyecto”. Se abrirá una nueva pestaña.
67
Figura 49. Pantalla eliminar proyecto
•
Se deberá seleccionar el proyecto a eliminar y pulsar en “Baja”. (Este proceso
eliminará todas las referencias al proyecto existentes así como los gastos y las
tareas relacionadas)
13.1.1.c. Ver datos proyecto:
•
Loguearse con permisos de administrador o coordinador del proyecto.
•
Se mostrara una lista de proyectos a los que se pertenece.
•
Pulsar en el que se quiera ver.
•
Se mostrara una página con:
◦ Un menú con las diferentes opciones que puede hacerse en un proyecto.
◦ Un titulo que al pulsarlo se podrán ver los datos generales que definen el
proyecto.
68
Figura 50. Pantalla principal de un proyecto, sección datos proyecto
▪ Estos datos se pueden modificar, si se cambian y se pulsa el botón
“modificar” de la parte inferior.
◦ Una lista de tareas
Figura 51. Pantalla principal de un proyecto, sección lista tareas
▪ Se pueden pulsar para acceder
◦ Una lista de gastos, en el caso del usuario solo de sus propios gastos, en el
caso del administrador o coordinador los gastos de todo el proyecto.
69
Figura 52. Pantalla principal de un proyecto, sección lista gastos
◦ Una lista de usuarios.
Figura 53. Pantalla principal de un proyecto, sección lista usuarios
13.1.1.d. Añadir usuario:
•
Loguearse con los permisos del administrador o el coordinador del proyecto.
•
Acceder al proyecto.
•
Seleccionar en la sección de proyecto la opción “Añadir usuario” en el menú
izquierdo. Se abrirá una nueva pestaña.
70
Figura 54. Pantalla añadir usuario a proyecto
•
Seleccionar el usuario de la lista desplegable y seleccionar el rol con el que se
quiera añadir.
•
Pulsar el botón “Añadir” de la parte inferior para guardar los cambios.
•
Pulsar el botón “Cancelar” para cerrar la ventana.
13.1.1.e. Eliminar usuario:
•
Loguearse con los permisos del administrador o el coordinador del proyecto.
•
Acceder al proyecto.
•
Seleccionar en la sección de proyecto la opción “Eliminar usuario” en el menú
izquierdo. Se abrirá una nueva pestaña.
71
Figura 55. Pantalla eliminar usuario del proyecto
•
Seleccionar el usuario de la lista desplegable.
•
Se rellenara una lista de tareas en la parte inferior, estas tareas son las que tiene
asignadas el usuario y hay que re asignarlas. Para ello seleccionar un usuario de
la otra lista desplegable y pulsar en “Reasignar”.
Figura 56. Pantalla eliminar usuario del proyecto, sección reasignar tareas
•
Cuando todas las tareas hayan sigo reasignadas, pulse en el botón “Eliminar” de
debajo del nombre del usuario.
•
Pulsar el botón “Cancelar” para cerrar la ventana.
13.1.2 Tarea
13.1.2.a. Buscar tareas:
•
Puede entrar con cualquiera de los permisos.
72
•
Puede acceder desde el menú superior al seleccionar “Tarea” en la opción
“Buscar tarea” desde la pantalla donde están listados los proyectos del usuario o
desde la pantalla principal de cualquier proyecto.
•
Se muestra una pantalla con diferentes filtros a definir. Se ha de seleccionar al
menos un filtro.
Figura 57. Pantalla de búsqueda de tareas
•
Para poder eliminar todos los filtros seleccionados y crear una búsqueda nueva
se puede pulsar en limpiar.
•
Se pulsa en el botón “Buscar” y se listan debajo las tareas seleccionadas.
Figura 58. Lista de la búsqueda de tareas
73
◦ Si se pulsa en el icono de “ver” de una tarea, se abrirá una nueva pestaña con
los datos de la tarea seleccionada. (Ver punto 13.1.2.d. Ver tarea)
◦ Si se pulsa en el icono de “eliminar” se abrirá una nueva pestaña con los
datos de la tarea a eliminar y si está seguro podrá pulsar en “Baja” y
eliminarla. (Ver punto 13.1.2.c. Eliminar tarea)
13.1.2.b. Crear tarea:
•
Loguearse con los permisos del administrador o el coordinador del proyecto.
•
Acceder al proyecto.
•
Seleccionar la opción “Tarea” en el menú y pulsar en “Crear tarea”. Se abrirá
una nueva pestaña.
Figura 59. Pantalla crear tarea
•
Rellenar la tarea con los datos requeridos.
•
Pulsar en el botón “Crear” de la parte inferior.
•
Pulsar “Cancelar” para cerrar la ventana.
74
13.1.2.c. Eliminar tarea:
•
Loguearse con los permisos del administrador o el coordinador del proyecto.
•
Acceder al proyecto.
•
Seleccionar la opción “Tarea” en el menú y pulsar en “Eliminar tarea”. Se abrirá
una nueva pestaña.
Figura 60. Pantalla eliminar tarea
•
Escribir la id de la tarea a eliminar y pulsar en “Comprobar datos”.
•
Si la tarea existe y es la que se pretende eliminar pulsar en el botón “Eliminar”
de la parte inferior.
•
Pulsar “Cancelar” para cerrar la ventana.
13.1.2.d. Ver tarea:
•
Loguearse en el sistema con cualquier permiso.
•
Acceder al proyecto al cual pertenece la tarea, pulsando en la tabla.
•
Acceder a la tarea desde la tabla de tareas mostrada clicando en ella o desde la
búsqueda de tareas (Ver punto 13.1.2.a. Buscar tareas)
75
•
Se abrirá una nueva pestaña con dos secciones.
◦ La primera contendrá los datos generales de la tarea.
Figura 61. Pantalla ver tarea, sección de datos generales
◦ Los campos modificables pueden ser cambiados y se grabaran pulsando el
botón guardar.
◦ La sección de comentarios contiene una lista con los comentarios de esa
tarea.
76
Figura 62. Pantalla ver tarea, sección de comentarios
◦
Para poder añadir un comentario a la tarea se podrá realizar escribiendo en
el campo de texto debajo de la tabla y pulsando en “Añadir”.
◦ Para cerrar la pestaña pulsar en “Cerrar”.
13.1.3 Calendario
13.1.3.a. Mostrar el calendario:
•
Loguearse con cualquier permiso. Todos los usuarios tienen un calendario.
•
Se puede acceder desde la opción “Calendario” del menú superior de la pantalla
principal o de un proyecto.
•
Se mostrara por defecto los eventos de un mes.
77
Figura 63. Pantalla calendario, vista por mes
•
En la parte superior derecha se puede seleccionar el filtro por mes, por semana y
por día.
Figura 64. Pantalla calendario, vista por semana
78
Figura 65. Pantalla calendario, vista por día
•
Para moverse en el tiempo hay que pulsar las flechas de la parte superior
izquierda.
•
Para volver al mes o a la semana del día actual hay que pulsar en la opción
“Hoy” en la parte izquierda superior.
•
Para cerrar la pestaña del calendario hay que pulsar en “Cerrar” en la parte
inferior de la pantalla.
13.1.3.b. Ver evento del calendario:
•
Para ver un evento en detalle se ha de pulsar sobre el evento y se mostrara una
ventana emergente con los datos.
Figura 66. Pantalla calendario, evento de un mes
79
•
Si el evento contiene una url, se puede pulsar en ella y se redirigirá hacia la
pagina.
13.1.3.c. Crear evento del calendario:
•
Se abrirá una ventana emergente con un formulario para rellenar.
Figura 67. Pantalla crear evento
•
Pulsar sobre el día que del evento.
•
Rellenar los campos indicados.
•
Si se selecciona la opción “Todo el día” no hace falta indicar hora.
•
Pulsar en “Crear”.
•
Se mostrara en el calendario el evento creado.
13.1.3.d. Modificar evento del calendario:
•
Pulsar sobre el evento.
•
Se abrirá una ventana emergente con un formulario rellenado con los datos del
evento.
80
Figura 68. Pantalla modificar/eliminar evento
•
Modificar los campos indicados.
•
Pulsar en “modificar”.
•
Se mostrara en el calendario el evento modificado.
13.1.3.e. Eliminar evento del calendario:
•
Pulsar sobre el evento. (Ver figura 68)
•
Pulsar en “eliminar”.
•
Se eliminara en el calendario el evento indicado.
13.1.3.f. Mover eventos del calendario:
•
Arrastrar el evento al nuevo día seleccionado y soltar.
81
Figura 69. Pantalla arrastrar evento
•
Pulsar “Si” en el mensaje emergente donde pregunta “Esta seguro que desea
mover el evento?”.
•
Se mostrara en el calendario el evento movido.
13.1.3.g. Cambiar el tiempo del evento del calendario:
•
Pulsar en la parte inferior del evento y alargar o encoger el evento hasta la hora
deseada o el hasta el día deseado.
Figura 70. Pantalla cambiar tiempo evento
•
Soltar el evento.
13.1.4. Usuario
13.1.4.a. Crear usuario:
82
•
Loguearse con los permisos del administrador.
•
Seleccionar la opción “Usuario” del menú superior y pulsar en la opción “Crear
usuario”. Se abrirá una nueva pestaña.
Figura 71. Pantalla crear usuario
•
Rellenar los campos mostrados. Los indicados en amarillo son obligatorios.
•
Marcar la opción “Administrador” para que el nuevo usuario tenga permisos de
administrador.
•
Marcar la opción “Activo” para que el nuevo usuario pueda acceder cuando se
haya creado el usuario.
•
Pulsar en el botón “Alta” en la parte inferior de la pantalla.
83
•
Se mostrará un mensaje de confirmación si se ha creado correctamente o de
error si no se ha creado.
•
Pulsar en cancelar para cerrar la pestaña.
13.1.4.b. Eliminar usuario:
•
Loguearte con permisos de administrador.
•
Seleccionar la opción “Usuario” del menú superior y pulsar en la opción
“Eliminar usuario”. Se abrirá una nueva pestaña.
Figura 72. Pantalla de eliminar usuario
•
Escribe el usuario que desea eliminar y pulsa en el botón “Comprobar datos” de
la parte inferior para comprobar si existe el usuario y rellenar los datos del
formulario. De esta manera se comprueba que realmente es el usuario que se
desea eliminar.
•
Pulsa en el botón “Baja” y el usuario sea desactivado del sistema y se eliminaran
todas las referencias de él.
•
El botón “Cancelar” cierra la pestaña.
13.1.4.c. Añadir y eliminar varios usuarios de un proyecto:
•
Loguearse con permisos de administrador
84
•
Seleccionar “Usuario” del menú superior y pulsar en “Añadir y suprimir
usuarios” del menú desplegable.
Figura 73. Pantalla para añadir y quitar usuarios
•
En la nueva ventana, seleccionar el proyecto al que se desea modificar los
usuarios.
•
Al seleccionar el proyecto se rellenaran las dos listas con los usuarios. La de la
izquierda es la que contiene los usuarios del proyecto y la derecha los restantes
del sistema.
•
Para añadir se seleccionar el rol con el que se quieren añadirán los usuarios al
proyecto.
•
Se selecciona de la lista de la derecha el usuario y le da a la fecha que apunta a
la izquierda.
•
Para suprimir se selecciona de la izquierda los usuarios y se pulsa en la fecha
que apunta a la derecha.
85
13.1.4.d. Consultar/Modificar perfil:
•
Para modificar o consultar el propio perfil puede loguearse con cualquier
permiso.
◦ Se abrirá una nueva pestaña con el formulario rellenado con los datos del
usuario actual.
Figura 74. Pantalla usuario consultar/Modificar perfil (Permisos usuario)
◦ El campo contraseña y confirmación de contraseña estarán vacíos, si se
quiere modificar la contraseña actual se deberán rellenar, en caso contrario
dejarlos vacíos.
◦ Pulsar en el botón “Modificar”.
◦ Para salir pulsar “Cancelar”.
86
•
Para modificar o consultar un perfil de otro usuario debe loguerse con permisos
de administrador.
◦ Se abrirá una nueva pestaña con el formulario rellenado con los datos del
usuario actual.
Figura 75. Pantalla Consultar/Modificar perfil de usuario(Permisos administrador)
◦ Cambiar el usuario propio del campo “Usuario” por el usuario que se
pretende consultar/modificar.
◦ Pulsar en “Comprobar datos” para que se rellenen los datos del usuario
indicado.
◦ Si el usuario es correcto, modificar los datos y pulsar en “Modificar”.
87
◦ El campo contraseña y confirmación de contraseña estarán vacíos, si se
quiere modificar la contraseña actual se deberán rellenar, en caso contrario
dejarlos vacíos.
13.1.4.e. Modificar permisos usuarios:
•
Loguearse con permisos de administrador o coordinador de proyecto.
•
Acceder al proyecto al que se le quiere cambiar los permisos del usuario.
•
En el menú superior seleccionar “Usuario” y pulsar en “Modificar los permisos
de los usuarios”.
•
Se abrirá una pestaña nueva con dos listas desplegables y un campo de texto.
Figura 76. Pantalla modificar permisos usuario
•
En la primera lista seleccionar el usuario. Al seleccionarlo se rellenará el campo
de texto con los permisos actuales del usuario. En la segunda lista seleccionar el
nuevo permiso.
•
Pulsar en “Modificar” para guardar los cambios y en “Cancelar” para cerrar la
ventana.
13.1.5 Contabilidad
13.1.5.a. Ver estado contabilidad:
88
•
Loguearse con permisos de coordinador de proyecto o administrador
•
Acceder al proyecto que se quiera mirar la contabilidad pulsando en la lista de
proyectos.
•
En el menú superior del proyecto, seleccionar la “Contabilidad” y pulsar en
“Visión general”. Se abrirá una nueva pestaña.
•
En la parte superior de la pantalla están los datos generales con el dinero total, el
restante y el gastado.
Figura 77. Pantalla Visión general de la contabilidad, sección datos proyectos
•
El botón de modificar sirve para realizar cambios en el dinero total y el nombre
de la entidad financiera.
•
Debajo hay una tabla con el resumen económico según las particiones por año y
categoría hechas y los gastos realizados.
89
Figura 78. Pantalla Visión general de la contabilidad, sección resumen económico
•
Debajo esta la sección por años. Donde se muestra una tabla con los gastos de
cada año.
Figura 79. Pantalla Visión general de la contabilidad, sección de gastos organizados por años
•
Para modificar estas particiones se puede pulsar en “Modificar partición por
años”. (Ver punto 13.1.5.b. Modificar partición categorías)
•
Debajo esta la sección por categorías. Se muestra una tabla con los gastos de
cada categoría.
90
Figura 80. Pantalla Visión general de la contabilidad, sección de gastos organizados por categorías
•
Para modificar estas particiones se puede pulsar en “Modificar partición por
categorías.(Ver punto 13.1.5.c. Modificar partición años)
•
El botón cancelar sirve para cerrar la pestaña.
13.1.5.b. Modificar partición categorías:
•
Loguearse con permisos de administrador o coordinador del proyecto.
•
Pulsar en el proyecto a modificar.
•
Seleccionar del menú lateral izquierdo la opción de “Visión general” dentro de
la sección de contabilidad.
•
Pulsar en el botón “Modificar partición por años”
•
Se abrirá una nueva pestaña con diferentes secciones según la acción a realizar.
◦ Datos proyecto:
Figura 81. Pantalla partición por categorías, sección datos de proyecto
91
▪ Aparecerá el proyecto y el dinero restante por gastar.
◦ Crear categoría nueva:
Figura 82. Pantalla partición por categorías, sección de crear categoría nueva
▪ Rellenar el nombre de la nueva categoría.
▪ Rellenar el dinero.
▪ Pulsar en “Crear”
◦ Modificar categoría proyecto:
▪ Renombrar una categoría del proyecto:
Figura 83. Pantalla partición por categorías, sección de renombrar categoría
•
Seleccionar la categoría.
•
Rellenar el nuevo nombre que tendrá.
•
Pulsar en “Renombrar”.
▪ Modificar dinero de la categoría:
92
Figura 84. Pantalla partición por categorías, sección de modificar el dinero de una categoría
•
Seleccionar la categoría de la lista desplegable.
•
Rellenar el dinero a modificar. La nueva cantidad no puede ser menor
al total gastado. Si es menor, deberá modificar los gastos moviendolos a otra categoría. (Ver punto )
◦ Eliminar categoría proyecto:
▪ Seleccionar de la lista desplegable la categoría a eliminar.
Figura 85. Pantalla partición por categorías, sección de eliminar una categoría
•
Si tiene gastos (tanto generales como por año) se deberán mover para
poder borrarla. Para ello aparecerá una sección para permitir moverlos.
93
Figura 86. Pantalla partición por categorías, sección emergente de mover gastos a otras categorías
◦ Ver los datos del gasto:
▪ Pulsar en el gasto.
▪ Se rellenarán los campos de debajo.
◦ Mover varios gastos juntos:
▪ Seleccionar todos los gastos de la lista años. (la lista es
multiseleccionable)
▪ Seleccionar si la categoría se quiere a nivel general o
seleccionar el año.
▪ Seleccionar la categoría.
▪ El dinero restante de la categoría debe ser mayor que el
dinero total de los gastos a mover en ella.
▪ Pulsar en mover
◦ Pulsar en “Eliminar”.
13.1.5.c. Modificar partición años:
94
•
Loguearse con permisos de administrador o coordinador del proyecto.
•
Pulsar en el proyecto a modificar.
•
Seleccionar del menú lateral izquierdo la opción de “Visión general” dentro de
la sección de contabilidad.
•
Pulsar en el botón “Modificar partición por años”
•
Se abrirá una nueva pestaña con diferentes secciones según la acción a realizar.
◦ Crear un año:
Figura 87. Pantalla partición años, sección de crear año
▪ Primera sección, rellenar el campo año y pulsar en “Crear”
◦ Eliminar año:
Figura 88. Pantalla partición años, sección de eliminar año
▪ Seleccionar un año de la lista desplegable y pulsar en “Eliminar año”
◦ Añadir categoría a año:
95
Figura 89. Pantalla partición años, sección de añadir categoría a año
▪ Seleccionar un año de la lista desplegable.
▪ Seleccionar la categoría general que se le añadirá al año.
▪ Rellenar el dinero que tendrá la categoría del año que no supere el dinero
de la categoría general.
▪ Pulsar en añadir.
◦ Eliminar categoría de año:
Figura 90. Pantalla partición años, sección de eliminar categoría de año
▪ Seleccionar un año
▪ Seleccionar la categoría a eliminar.
•
Si la categoría contiene gastos se deberán mover a otra categoría
diferente.
•
Se mostrará una lista con los gastos de la categoría a eliminar.
Figura 91. Pantalla partición años, sección emergente de mover gastos
96
•
Seleccionar un gasto.
•
Seleccionar una categoría diferente del año en la lista desplegable
anexa.
•
Pulsar en “Mover gasto”
•
Cuando todos los gastos se hayan movido podrá eliminar la
categoría.
▪ Pulsar en eliminar “Categoría”.
◦ Mover dinero del año:
Figura 92.Pantalla partición años, sección de mover dinero del año
▪ Rellenar la cantidad de dinero a mover.
▪ Seleccionar el año del que se moverá.
▪ Seleccionar la categoría de la cual se moverá.
▪ Seleccionar el año destinatario.
▪ Seleccionar la categoría destinataria.
▪ Pulsar en “Mover dinero”
13.1.5.d. Buscar gastos:
•
Puede entrar con cualquiera de los permisos.
•
Puede acceder desde el menú superior al seleccionar “Contabilidad” en la opción
“Buscar gastos” desde la pantalla donde están listados los proyectos del usuario
o desde la pantalla principal de cualquier proyecto.
•
Se muestra una pantalla con diferentes filtros a definir. Se ha de seleccionar al
menos un filtro.
97
Figura 93. Pantalla de buscar gastos, filtros de búsqueda
•
Para poder eliminar todos los filtros seleccionados y crear una búsqueda nueva
se puede pulsar en limpiar.
•
Se pulsa en el botón “Buscar” y se listan debajo los gastos seleccionados.
Figura 94. Pantalla de buscar tareas, lista filtrada
98
◦ Si se pulsa en el icono de “ver” de un gasto, se abrirá una nueva pestaña con
los datos de del gasto seleccionada. (Ver punto 13.1.5.g. Ver gasto)
◦ Si se pulsa en el icono de “modificar” se abrirá una nueva pestaña con los
datos del gasto a modificar. Esta opción solo es posible para el
administrador y el coordinador del proyecto de ese gasto. (Ver punto
13.1.5.h. Modificar gasto)
◦ Si se pulsa en el icono de “eliminar” se abrirá una nueva pestaña con los
datos del gasto a eliminar y si está seguro podrá pulsar en “Baja” y
eliminarlo. (Ver punto 13.1.5.f. Eliminar gasto)
13.1.5.e. Añadir gasto:
•
Loguearse con los permisos de administrador o coordinador de proyecto al
cual pertenecerá el gasto.
•
Acceder al proyecto al que pertenece el gasto desde la lista de proyectos.
•
Seleccionar en el menú superior la opción “Contabilidad” y pulsar en “Añadir
gasto”.
•
Se abrirá una nueva pestaña con un formulario que se debe rellenar.
99
Figura 95. Pantalla de crear gasto
•
En la parte inferior hay tres listas desplegables que definirán el año y la
categoría a la que pertenecerá el gasto.
◦ Para que sea un gasto perteneciente a un año en particular seleccionar un
valor de la lista de años y a continuación una de sus categorías.
◦ Si se quiere dejar como un gasto general, que no pertenezca a ningún año,
seleccionar un valor únicamente de la lista desplegable.
•
Pulsar en el botón “Añadir”.
100
13.1.5.f. Eliminar gasto:
•
Loguearse con los permisos de administrador o coordinador de proyecto al
cual pertenecerá el gasto.
•
Acceder al proyecto al que pertenece el gasto desde la lista de proyectos.
•
Seleccionar en el menú superior la opción “Contabilidad” y pulsar en “Eliminar
gasto”.
Figura 96. Pantalla de eliminar gasto
•
Se abrirá una nueva pestaña con un formulario con el campo id gasto habilitada
y el resto de campos des habilitados. Hay que rellenar la id del gasto y pulsar en
el botón “Comprobar” de la parte inferior del formulario.
•
Cuando se hayan rellenado los campos y se haya comprobado que es el gasto
correcto. Pulsar en “Eliminar”.
101
•
El botón “Cancelar” sirve para cerrar la pestaña nueva abierta.
13.1.5.g. Ver gasto:
•
Loguearse con cualquier permiso.
•
Pulsar en el proyecto al cual pertenezca el gasto.
•
Aparecerá una lista de gastos en la parte inferior de la pantalla:
◦ En el caso del investigador aparecerán sus gastos.
◦ En el caso del administrador o coordinador aparecerán los de todo el
proyecto.
•
Para ver un gasto, pulsar en él.
Figura 97. Pantalla de ver gasto
•
También se pude acceder desde la opción “Buscar gasto” en el apartado
“Contabilidad”. (Ver punto 13.1.5.d. Buscar gastos)
•
Para salir pulsar en “Cancelar”
102
13.1.5.h. Modificar gasto:
•
Loguearse con permisos de administrador o coordinador de proyecto.
•
Acceder al proyecto seleccionado.
•
Pulsar en “Buscar gastos” en la sección “Contabilidad”.(Ver punto )
•
Pulsar en la columna “Modificar” del gasto seleccionado.
•
Se abrirá una ventana con el formulario rellenado.
Figura 98. Pantalla de modificar gasto
•
Cambiar los datos:
◦ Para las categorías:
103
▪ Si el gasto no pertenece a ningún año en particular, seleccionar la lista
desplegable de “Categoría general”. (Dejar en blanco el año y la
categoría año)
▪ Si el gasto pertenece a un año, seleccionar el año y seguidamente la
“Categoría año”. (Dejar en blanco la general)
•
Pulsar en “Modificar”.
•
Pulsar en “Cancelar” para cerrar la ventana.
104