UNIVERSIDAD CENTRAL DEL ECUADOR
FACULTAD DE INGENIERÍA, CIENCIAS FÍSICAS Y MATEMÁTICA
CARRERA DE INGENIERÍA INFORMÁTICA
"SISTEMATIZACIÓN WEB PARA LA AUTOMATIZACIÓN DEL
PROCESO DE GESTIÓN DE LAS TESIS DE GRADO EN LA FACULTAD
DE JURISPRUDENCIA DE LA UNIVERSIDAD CENTRAL DEL
ECUADOR"
TRABAJO DE GRADUACIÓN
PREVIO A LA OBTENCIÓN DEL TÍTULO DE INGENIERO
INFORMÁTICO
AUTOR:
Mario Daniel Castellanos Veintimilla
TUTOR:
Ing. Mauro Leonardo Rosas Lara, MSc.
QUITO - ECUADOR
2015
ii
DEDICATORIA
El presente proyecto de Tesis va dedicado a las personas que han estado conmigodirecta e indirectamente presentes, durante todos los aspectos de mi vida.
A Dios
Por darme las fuerzas y guiarme durante el transcurso de mi vida.
A mis Padres Teresa y José
A mis padres que me han apoyado incondicionalmente a lograr mis metas y objetivospropuestos. Gracias a sus consejos que han sido mi guía durante las etapas de mivida.
Gracias por enseñarme que con esfuerzo y dedicación se puede lograr muchas cosas.
A mis Hermanos Rodney, Esteban y Ana Cristina.
Por estar a mí lado en todo este arduo trabajo y por brindarme su apoyo y amistad.
A mi Novia Mónica
A mi amada novia, por su confianza, apoyo, comprensión y amor por estar conmigoen aquellos momentos en el que el estudio y trabajo ocuparon mi tiempo y esfuerzo.Gracias por ser parte de mi vida, te amo.
Mario Castellanos
iii
AGRADECIMIENTO
Agradezco tanto a Dios por darme la sabiduría, las fuerzas y sobre todo la pacienciapara llegar a la culminación de este proyecto.
A mis padres por su constante ayuda, confianza y sacrificio que tuvieron cada díapara poder brindarme lo necesario, para mí siempre serán los padres ejemplares.Gracias por todo.
A mis hermanos por ser el apoyo diario que tuve durante este proceso, por laconfianza que tuvieron en mí y por enseñarme grandes valores.
A mis tíos y primos ya que de una u otra manera siempre me brindaban sus consejosy ánimos para seguir adelante.
Y te agradezco tanto a ti, Mi Abuelita Mercedes que aunque ya no estés físicamentejunto a mí sé que estás feliz junto a Dios. A ti gracias siempre fuiste mi guía, porbrindarme tu amor.
Te agradezco tanto a ti, Mi primita Yolanda aunque ya no estés físicamente junto amí, sé que estas junto a Dios y desde ahí me miras y me guías. A ti gracias, porbrindarme tu ayuda cuando lo necesite, por enseñarme que con esfuerzo y dedicaciónse alcanzan los sueños aunque en el trayecto existan muchos obstáculos. Gracias.
A mi querida novia Mónica por estar a mí lado apoyando, bríndame su amor y portenerme paciencia en aquel momento que este proyecto ocuparon mi tiempo.
A mi Tutor y Revisores, les agradezco por la ayuda que me brindaron y por su guíadurante este proyecto.
A mis amigos por brindarme su apoyo y guía durante todo este proyecto.
A todos un GRACIAS por estar conmigo y que Dios los Bendiga. Gracias.
Mario Castellanos
v
CERTIFICACIÓN DEL TUTOR
vi
INFORME FINAL DEL TUTOR
viii
CALIFICACIÓN DEL TRABAJO DE GRADUACIÓN
ix
CONTENIDO
DEDICATORIA .......................................................................................................... ii
AGRADECIMIENTO ................................................................................................ iii
AUTORIZACIÓN DE LA AUTORÍA INTELECTUAL...................................... iv
APROBACIÓN DEL TUTOR..................................................................................... v
APROBACIÓN DEL TRIBUNAL............................................................................vii
CONTENIDO ............................................................................................................. ix
LISTADO DE TABLAS.............................................................................................. xiv
RESUMEN................................................................................................................. xv
ABSTRACT.............................................................................................................. xvi
CERTIFICADO DE TRADUCCIÓN DE RESUMEN............................................xvii
1. CAPITULO I. ....................................................................................................... 1
1.1. Introducción ................................................................................................. 1
1.2. Justificación ................................................................................................. 1
1.3. Objetivos de la Investigación ...................................................................... 2
1.3.1. Objetivo General .................................................................................. 2
1.3.2. Objetivos Específicos ........................................................................... 2
1.4. Alcance ......................................................................................................... 2
1.5. Limitaciones ................................................................................................. 3
1.6. Análisis de Herramientas............................................................................ 4
1.6.1. Plataforma ............................................................................................ 4
1.6.2. Motor de Base de Datos (Postgres) ..................................................... 6
1.6.3. Servidor de Aplicaciones JBOSS ........................................................ 6
1.6.4. Herramientas BPM .............................................................................. 6
1.6.5. Análisis de Gestores Documentales(ECM) ....................................... 8
1.6.6. Análisis de los Sistemas Operativos.................................................. 10
x
2. CAPITULO II. .................................................................................................... 12
2.1. Metodología de Investigación ................................................................... 12
2.2. Metodología de Desarrollo........................................................................ 12
2.3. Metodología RUP ...................................................................................... 15
2.4. Fases de la Metodología RUP ................................................................... 16
2.4.1. Fase de Inicio ...................................................................................... 16
2.4.2. Fase de Elaboración ........................................................................... 17
2.4.3. Construcción ....................................................................................... 23
2.4.4. Transición ........................................................................................... 23
3. CAPITULO III.................................................................................................. 25
3.1. FASE DE INICIO...................................................................................... 25
3.1.1. Descripción del proceso ..................................................................... 25
3.1.2. Diagrama Lógico del proceso ............................................................ 27
3.1.3. Actores del proceso ............................................................................ 28
3.1.4. Modelado del Negocio ........................................................................ 29
3.1.5. Modelo de Casos de Uso y Diagramas de secuencia del Negocio....... 30
3.2. FASE DE ELABORACIÓN ..................................................................... 39
3.2.1. Construcción del Modelo de Datos del Sistema............................... 39
3.2.2. Construcción del Modelo Orientado a Objetos del Sistema........... 40
3.2.3. Modelo de Clases ................................................................................ 41
3.3. FASE DE CONSTRUCCION .................................................................. 44
3.3.1. Modelo de Implementación ............................................................... 44
3.3.2. Flujo del Proceso de Gestión de Tesis .............................................. 45
3.4. FASE DE TRANSICION.......................................................................... 46
3.4.1. Manual de Instalación ....................................................................... 46
3.4.2. Manual de Usuario ............................................................................. 46
xi
3.5. FASE DE PRUEBAS................................................................................. 47
3.5.1. Recursos requeridos........................................................................... 47
3.5.2. Plan de Pruebas .................................................................................. 48
3.5.3. Pruebas de Carga ............................................................................... 49
3.5.4. Pruebas de Stress ............................................................................... 52
4. CAPITULO IV. ................................................................................................. 56
4.1. Conclusiones............................................................................................... 56
4.2. Recomendaciones....................................................................................... 57
5. ANEXOS............................................................................................................ 60
xii
LISTADO DE FIGURAS
Figura 1. Arquitectura JEE ...................................................................................................................... 4
Figura 2. Ejemplo de Diagrama lógico del proceso de Gestión de Tesis............................................... 18
Figura 3. Representación Proceso. ....................................................................................................... 19
Figura 4. Representación Actor ............................................................................................................ 19
Figura 5. Representación Caso de Uso ................................................................................................. 20
Figura 6. Ejemplo diagrama caso de uso (Administración del sistema) ............................................... 20
Figura 7. Representación Diagrama de Secuencia ............................................................................... 21
Figura 8. Ejemplo Diagrama de Secuencia ........................................................................................... 21
Figura 9. Representación Base de datos.............................................................................................. 22
Figura 10. Ejemplo de Base de Datos (Abstracto) ................................................................................ 22
Figura 11. Diagrama Lógico del Proceso .............................................................................................. 27
Figura 12. Diagrama Abstracto de los Departamentos........................................................................ 30
Figura 13. Caso de Uso: Administración del Sistema.......................................................................... 31
Figura 14. Diagrama de Secuencia: Administración del Sistema ......................................................... 32
Figura 15. Caso de Uso: Iniciar Proceso................................................................................................ 33
Figura 16. Diagrama de Secuencia: Iniciar Proceso ............................................................................. 34
Figura 17. Caso de Uso: Subir archivo .................................................................................................. 35
Figura 18. Diagrama de Secuencia: Subir Archivo ............................................................................... 35
Figura 19. Caso de Uso: Pre revisión plan tesis .................................................................................... 36
Figura 20. Diagrama de Secuencia: Pre Revisión Plan Tesis ................................................................. 37
Figura 21. Tutoría de Tesis ................................................................................................................... 38
Figura 22. Diagrama de Secuencia Tutoría Tesis.................................................................................. 38
Figura 23. Modelo de Base de Datos.................................................................................................... 39
Figura 24. Modelo Orientado a Objetos. .............................................................................................. 40
Figura 25. Diagrama de Clases (1) ....................................................................................................... 41
Figura 26. Diagrama de Clases (2)....................................................................................................... 42
xiii
Figura 27. Diagrama de Clases (3) ....................................................................................................... 43
Figura 28. Diagrama de Componentes................................................................................................. 44
Figura 29. Subproceso Registro Estudiante .......................................................................................... 45
Figura 30. Subproceso Calificar Documento........................................................................................ 46
Figura 31. Subproceso Revisión Oficio defensa Oral ............................................................................ 46
Figura 32. Prueba de Carga - Performance Data ................................................................................. 50
Figura 33. Prueba de Carga –Bandwidth ............................................................................................. 51
Figura 34. Prueba de Carga – Error ...................................................................................................... 52
Figura 35. Prueba de Estrés – Performance ......................................................................................... 53
Figura 36. Prueba de Estrés – Bandwidth............................................................................................. 54
Figura 37. Prueba de Estrés – Error ...................................................................................................... 55
xiv
LISTADO DE TABLAS
Tabla 1. Tabla Análisis Comparativa entre BPM .................................................................................... 8
Tabla 2. Tabla Criterios para evaluación entre ECM ............................................................................. 9
Tabla 3. Tabla Comparativa de las Plataformas ................................................................................. 11
Tabla 4. Tabla de Criterio para selección de Metodología................................................................... 15
Tabla 5. Escala de Valoración............................................................................................................... 15
Tabla 6 .Ejemplo Caso Uso (Administración del sistema).................................................................... 20
Tabla 7. Definición del Caso de Uso: Administración del Sistema ........................................................ 31
Tabla 8. Definición Caso de Uso: Iniciar Proceso .................................................................................. 33
Tabla 9. Definición Caso de Uso: Subir Archivo .................................................................................... 35
Tabla 10. Pre revisión plan de tesis ...................................................................................................... 36
Tabla 11. Definición Caso de Uso: Tutoría Tesis ................................................................................... 37
Tabla 13. Requisitos Hardware Pruebas.............................................................................................. 47
Tabla 14. Requisitos Software Pruebas ................................................................................................ 48
Tabla 12. Plan Pruebas Gestión Usuario .............................................................................................. 49
xv
RESUMEN
"SISTEMATIZACIÓN WEB PARA LA AUTOMATIZACIÓN DEL
PROCESO DE GESTIÓN DE LAS TESIS DE GRADO EN LA
FACULTAD DE JURISPRUDENCIA DE LA UNIVERSIDAD
CENTRAL DEL ECUADOR"
El presente trabajo, trata sobre el desarrollo de un sistema WEB, que
permite cubrir la necesidad de que el proceso de gestión de tesis se lo realice
de manera manual, tal como se lo está manejando de manera manual en la
Facultad de Jurisprudencia de la Universidad Central del Ecuador, para esto se
plantea el requerimiento de desarrollar una plataforma que integre las
diferentes herramientas; tales como para automatizar el flujo de la gestión de
las tesis, el control de los documentos, la intervención de reglas de negocio y
administración de usuarios.
Finalmente este trabajo se complementa mediante el desarrollo del proceso
de Aprobación de Tesis, Calificación Documento de Tesis, Defensa Oral y
Registro de Notas Finales de grado, utilizando la plataforma conformada, por
herramientas de software libre.
DESCRIPTORES:
GESTIÓN DOCUMENTAL / AUTOMATIZACIÓN DE PROCESOS /
JAVA /ADMINISTRACION DE USUARIOS / BONITA OPEN
SOLUTION /ALFRESCO / DROOLS
xvi
ABSTRACT
"SYSTEMATISATION WEB FOR THE AUTOMATION OF THE
PROCESS OF MANAGEMENT OF THE THESES OF DEGREE IN
THE FACULTY OF JURISPRUDENCE OF THE CENTRAL
UNIVERSITY OF THE ECUADOR"
The present work, treats on the development of a system WEB, that allows to
cover the need that the process of management of thesis realize it to him of
manual way, such as it is it to him handling of manual way in the Faculty of
Jurisprudence of the Central University of the Ecuador, for this poses the
request to develop a platform that integrate the different tools; such as to
automate the flow of the management of the theses, the control of the
documents, the intervention of rules of business and administration of users.
Finally this work complements by means of the development of the
process of Approval of Thesis, Qualification Document of Thesis, Oral
Defense and Register of Final Notes of degree, using the platform conformed,
by tools of free software.
DOCUMENT MANAGEMENT / PROCESS AUTOMATION / JAVA
/USER MANAGEMENT/ BONITA OPEN SOLITION / ALFRESCO /
DROOLS
DESCRIPTORES:
xvii
CERTIFICADO DE TRADUCCIÓN DE RESUMEN.
Por este medio, Yo, Mayra Rosalía Shuguli López con cedula No.
1716425135 certifico que la traducción de español a ingles del resumen del
trabajo de graduación, previo a la obtención del título de ingeniero
informático del egresado Mario Daniel Castellanos Veintimilla, fue realizada
por mi persona.
Particular que informo para los finespertinentes.
Atentamente.
Doc. Mayra Rosalía Shuguli López.
Traductor
xviii
1
1. CAPITULO I.
1.1. Introducción
Con el creciente aumento de la tecnología de hoy en día, ha contribuido al desarrollo
de potentes soluciones informáticas, las cuales han facilitado la automatización de
una gran cantidad de procesos, que tradicionalmente se realizan de forma manual.
Las ventajas y fortalezas que ofrece la tecnología han permitido tanto a instituciones
públicas como privadas aumentar en eficiencia y eficacia derivando en el incremento
de efectividad y confiabilidad en sus procesos.
Actualmente varias Instituciones han tenido que realizar cambios en la forma de
manejar los procesos, de una forma manual a automática debido al aumento de
usuarios y a que el rendimiento de trabajo se ve afectado.
Este es el caso de la Facultad de Jurisprudencia de la Universidad Central del
Ecuador, que gestiona toda lo referente a las tesis de grado de manera manual, con lo
que surge la necesidad de automatizar este proceso.
Para el desarrollo del aplicativo se utilizara herramientas de software libre, y además
está orientado con una visión futurista de enlazar con otros tipos de sistemas de
información y tecnologías que permitan contribuir con sus procesos.
El presente proyecto permitirá optimizar y automatizar el proceso de gestión de las
tesis de grado, servirá de apoyo y mejora del rendimiento del recurso humano.
1.2. Justificación
Actualmente en la Facultad de Jurisprudencia, el proceso de gestión de las tesis de
grado, es un aspecto muy importante que necesita ser tratado, razón por la cual es
necesaria la implementación de la tecnología.
Al momento de hablar de automatización del proceso de gestión de las tesis de grado,
se refiere a convertir las tareas manuales existentes en procesos electrónicos capaces
de efectuar el control, seguimiento y gestión de los mismos.
2
La Automatización del proceso de gestión de tesis de grado de la Facultad de
Jurisprudencia reducirá considerablemente el tiempo de iteración entre:
Personal administrativo y estudiantes
Docentes y personal administrativo
Y entre docente y estudiante
Debido que la mayoría del proceso lo podrá realizar desde un entorno web.
Mejorando los tiempos de respuesta a los estudiantes y docentes, respuestas
automáticas personalizadas y resultados en diferentes formatos como en PDF1.
1.3. Objetivos de la Investigación
1.3.1. Objetivo General
Brindar a la Facultad de Jurisprudencia de la Universidad Central una plataforma que
permita automatizar el proceso de gestión de las tesis de grado y la gestión
documental, mediante el uso de herramientas de Código Abierto, con el fin de
disponer de una herramienta BPM2 que permita encaminar la información,
conjuntamente con un contenedor digital de documentos.
1.3.2. Objetivos Específicos
1. Facilitar a la Facultad de Jurisprudencia herramientas de gestión documental
y BPM que trabajen de manera conjunta, facilitando el manejo y consulta de
la información.
2. Crear un repositorio centralizado que permita almacenar la información
documental que se maneja durante el proceso de la tesis, para poder
disponer de ella en cualquier momento y cualquier lugar.
3. Automatizar el proceso de para realizar la tesis de grado.
1.4. Alcance
El propósito es proporcionar a la Facultad de Jurisprudencia un sistema confiable y
fácil de usar para el usuario, que permita mejorar la eficiencia a través de la gestión
sistemática del proceso, que se deben modelar, automatizar y optimizar de manera
continua con la ayuda de una herramienta BPM.
1 PDF Portable Document Format, es un formato de almacenamiento de documentos digitalesindependiente de plataformas de software o hardware.2 BPM Business Process Management: http://www.ibermatica.com/ibermatica/bpm
3
El sistema constará de lo siguiente:
Ingreso al Sistema
Previo al uso del sistema, el usuario deberá autenticarse para el ingreso al mismo con
su nombre de usuario y contraseña respectivo y contará con las respectivas
seguridades del caso.
Gestión de Usuarios y Perfiles
En la gestión de usuarios se manejaran perfiles para el acceso a las dos partes
que conforman el sistema otorgando los permisos correspondientes.
Gestión del proceso de las tesis de grado
Permitirá realizar el cambio de estado de un estudiante a egresado, registro del plan
de tesis para la aprobación, la asignación del docente que aprueba la tesis, asignación
del tutor de tesis, asignación del tribunal, ingreso de la aprobación del tema de tesis,
las notas tanto del tutor como del tribunal, la recepción de los documentos finales y
establecer la fecha de grado, para cada uno de estos se debe emitir un comprobante y
seguimiento.
El sistema permite generar los reportes de:
Reportes de los estudiante registrados en el sistema.
Reportes de los tesistas graduados.
Reporte de los planes de Tesis dado el estado de la tesis (APROBADO,
RECHAZADOS Y PENDIENTES).
Reporte de Tesis que están a cargo de un profesor tanto de revisor como de
tutor.
Los reportes tendrán el formato PDF, para la facilidad de impresión.
Los oficios y el plan de tesis se almacenarán en el repositorio, a excepción de los
reportes.
1.5. Limitaciones
Tomando en cuenta los objetivos, y en base al desarrollo de la presente tesis se
consideraron las siguientes limitaciones:
El sistema no realiza la migración de la información.
La categorización de los tutores y de los miembros del tribunal será realizado
manualmente.
4
El seguimiento de las tesis no se hará de manera continua, solo se establecerá el
tiempo máximo de entrega a partir de la aprobación del mismo.
La designación de que un estudiante es egresado se lo debe realizar de manera
manual.
Los planes de Tesis que se podrán cargan en el sistema, deben estar en formato
PDF.
El tamaño máximo permitido para la carga del plan de tesis no puede superar los2MB.
1.6. Análisis de Herramientas
1.6.1. Plataforma
Arquitectura JEE
Java Platform, Enterprise Edition o JEE3, 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.
Figura 1. Arquitectura JEEFuente:
3 Java EE, Plataforma de programación. Obtenido desde: http://es.wikipedia.org/wiki/Java_EE
5
Enterprise Java Bean
Los Enterprise JavaBeans (también conocidos por sus siglas EJB) son una de
las API que forman parte del estándar de construcción de aplicaciones
empresariales JEE (ahora JEE 5.0) de Oracle Corporation (inicialmente
desarrollado por Sun Microsystems). Su especificación detalla cómo los
servidores de aplicaciones proveen objetos desde el lado del servidor que son,
precisamente, los EJB:
Características:
Comunicación remota utilizando RMI.
Transacciones.
Control de la concurrencia.
Eventos utilizando JMS (Java messaging service).
El objetivo de los EJB es dotar al programador de un modelo que le permita
abstraerse de los problemas generales de una aplicación empresarial
(concurrencia, transacciones, persistencia, seguridad, etc.) para centrarse en el
desarrollo de la lógica de negocio en sí.
Session EJB
Los Session EJB se encargan de gestionar el flujo de la información en el
servidor.
Existen dos Tipos:
Con estado (stateful). Son objetos distribuidos que poseen un estado. El
estado no es persistente, pero el acceso al bean se limita a un solo cliente.
Sin estado (stateless). Son objetos distribuidos que carecen de estado
asociado permitiendo por tanto que se los acceda concurrentemente. No se
garantiza que los contenidos de las variables de instancia se conserven
entre llamadas al método.
Java Persistence API (JPA)
Java Persistence API, más conocida por su sigla JPA, es la API de
persistencia desarrollada para la plataforma Java EE e incluida en el estándar
EJB3. Esta API busca unificar la manera en que funcionan las utilidades que
proveen un mapeo objeto-relacional. El objetivo que persigue el diseño de esta
6
API es no perder las ventajas de la orientación a objetos al interactuar con una base
de datos, como sí pasaba con EJB2, y permitir usar objetos regulares (conocidos
como POJOs).
1.6.2. Motor de Base de Datos (Postgres)
Es un sistema de gestión de base de datos relacional orientada a objetos. Las
principales características son: alta concurrencia, amplia variedad de tipos
nativos, etc.
1.6.3. Servidor de Aplicaciones JBOSS
JBoss4 es un servidor de aplicaciones JEE5 que ofrece una plataforma de alto
rendimiento para aplicaciones java, aplicaciones Web, Portales y e- business.
JBoss puede ser descargado, utilizado, incrustado, y distribuido sin restricciones por
la licencia. Por este motivo es la plataforma más popular de middleware para
desarrolladores.
Características:
Producto de licencia de código abierto sin coste adicional.
Confiable a nivel de empresa.
Incrustable
Orientado a arquitectura de servicios.
Flexibilidad consistente.
Soporte completo para JMX.
1.6.4. Herramientas BPM
Para el análisis se tomara las siguientes soluciones BPM: jBossjBPM5, Intalio6,
Process Maker7, Bonita8.
4 JBOSS, Servidor de aplicaciones. Obtenido desde: http://es.wikipedikia.org/wiki/JBoss5 Diseñador Gráfico de Proceso JBoss jBPM. Obtenido el 01 de mayo de 2013 desdehttp://docs.jboss.org/jbpm/v3/spanish/jbpm-gpd-installation-spanish.pdf6 Intalio BPMN. Obtenido el 01 de mayo de 2013 desde http://www.sidesoft-ecuador.com/productos-y-servicios/sideconsulting/intaliobpm.html7 ProcessMaker, workflowSimplified. Obtenido el 01 de mayo de 2013 desdehttp://wwwhatsnew.com/2008/07/21/processmaker-bpm-orientado-a-todo-tipo-de-diseno-y-flujo-de-procesos/.8 Bonita, Obtenido el 01 de mayo de 2013 desde http://es.bonitasoft.com/
7
Se cuantificara en base a la escala entre 1 (no tiene o no existe) y 4 (cumple al
100%), de acuerdo a la tabla a continuación.
Características jBPM Bonita IntalioProcess
Maker
1 Lenguaje de modelado de procesos 5 5 5 5
2 Lenguaje de Ejecución de procesos 5 5 5 0
3 Soporte XDPL? 0 0 0 0
4 Motor de Procesos 4 4 4 4
5 Diseñador de Procesos & app dev. 4 4 4 4
6 Diseñador de Procesos para usuarios
empresariales4 3 4 3
7 Business Activity Monitoring (BAM) 3 3 1 2
8 Business Rules Engine(BRE) 5 3 1 3
9 Integración con procesos y repositorio
de reglas5 4 1 1
10 Instancia de proceso, gestión de
informes y tareas de usuario a partir de
una visión de administración del
sistema.
4 4 4
11 Creación formularios Web 3 4 4 4
12 Integración de Gestión de Contenidos 1 3 2 3
13 Portal Integration 2 4 3 1
14 Simulación 2 3 1 0
15 Desarrollo de Aplicaciones Rápidas 1 4 4 3
16 Nivel de Madurez (casos de éxito, las
tecnologías utilizadas,..)4 4 3 3
8
17 Instalación 1 4 3 5
Total Pts. 53 61 49 45
Tabla 1. Tabla Análisis Comparativa entre BPMAutor: Mario Castellanos
Fuente: http://holisticsecurity.wordpress.com/2011/07/21/jbpm-bonita-intalio-processmaker-activiti-que-bpm-suite-uso/
Después de la valoración establecida a cada uno de los BPM, se puede concluir en
que la mejor solución encontrada es Bonita Open Solution.
Bonita Open Solution.9
La gestión de procesos, presenta varias ventajas tanto para analista, desarrolladores
y usuarios.
Ventajas:
Simplificar procesos y mejorar la productividad.
Permite interconectar personas, departamentos y sistemas.
Permite eliminar trámites basados en papel.
Reducir costos operacionales.
Aumentar ingresos.
Permite interconectar otras aplicaciones mediante el API Web Services, como
ERP, CRM, DMS, Email.
Interfaz intuitiva.
(Que puedo hacer, si es free, usos.)
1.6.5. Análisis de Gestores Documentales(ECM) 10
La necesidad de implementar un Sistema de Gestión Documental basado en
herramientas ECM Open Source, conduce a elaborar un análisis de las herramientas
ECM: Alfresco11 , Nuxeo. 12
9 Bonita Open solution, tomado de http://es.slideshare.net/frousseaux/todo-acerca-de-bonitasoft-openbpm.10 Comparativa entre ECM Obtenido el 01 de mayo del 2013 desdehttp://blog.athento.com/2009/02/alfresco-vs-nuxeo-gestion-documental.html11 Alfresco. Obtenido el 01 de mayo del 2013 desde http://www.cyberpymes.com/aplicaciones-a-medida/alfresco/alfresco-caracteristicas.html12 Nuxeo. Obtenido el 01 de mayo del 2013 desde http://www.athento.com/nuxeo/caracteristicas/
9
Se cuantificara en base a la escala entre 1 (no tiene o no existe) y 4 (cumple al
100%), de acuerdo a la tabla a continuación:
Tabla 2. Tabla Criterios para evaluación entre ECMAutor: Athento
Fuente: Athento.com
Después de la valoración establecida a cada uno de los ECM, se puede establecer que
la mejor solución encontrada es Alfresco.
Alfresco13
Es un gestor de contenido empresarial (ECM). Proporciona funciones para guardar y
localizar documentos electrónicos de cualquier tipo, catalogarlos de acuerdo con los
criterios definidos y gestionarlos según los procedimientos de la organización. El
principal objetivo de Alfresco es proporcionar un conjunto de funciones, a un coste
económico reducido.
Ventajas
Facilidad de uso
Gestión avanzada de búsquedas de documentos
Sistema virtual de ficheros inteligente.
Arquitectura distribuida.
Colaboración: Fórums
Extracción y categorización automática de metadatos desde las interfaces.
Auditoria
13 Alfresco, tomado de http://www.cyberpymes.com/aplicaciones-a-medida/alfresco-caracteristicas
10
Gestión Usuarios y seguridad con usuarios, grupos y roles.
1.6.6. Análisis de los Sistemas Operativos
A continuación tenemos un cuadro comparativo:
Comparativa GNU/Linux, Microsoft Windows
Aspecto GNU/Linux Windows
Filosofía Es un sistema al que cualquiera
puede acceder. Se puede distribuir,
usar y modificar libremente
Pertenece a una compañía,
Microsoft, que es la única
autorizada tanto de realizar
modificaciones como de
distribuirlo.
Precio Es software libre, de uso gratuito
con tantas licencias como se
deseen.
Dependiendo de las versiones,
cientos de euros por cada licencia.
Seguridad Extremadamente seguro. Su
sistema de permisos hace que los
pocos virus que existen no causen
ningún daño al sistema.
Absolutamente inseguro, existen
miles de virus y la instalación de
firewares, antivirus, etc… es
completamente necesaria. Algunos
de ellos pueden llegar a formatear
la partición Windows.
Facilidad de uso Para tareas cotidianas, la misma
que Windows. Según la
distribución, ciertas tareas
administrativas pueden suponer
pequeños problemas para los
usuarios más novatos. Día a día
mejora en este aspecto.
Precisamente la idea de Windows
era llevar la informática al usuario
más inexperto, descuidando sin
embargo otros aspectos de suma
importancia.
Difusión Poco extendido en hogares.
Utilizado casi por la totalidad de
servidores (los propios server de
Microsoft funcionan bajo Linux).
Ocupa el 90% del mercado de
ordenadores domésticos.
11
Disponibilidad de
programas
Existen programas para realizar
todas las tareas, aunque la
variedad no es tan grande como en
Windows.
Millones de programas de todo
tipo.
Compatibilidad
con otros sistemas
operativos
Se comunica por red con cualquier
sistema. Escribe en todos los
sistemas de archivos, si bien el
NTFS no lo controla con total
estabilidad, al no haber
proporcionado Windows todos sus
detalles.
Suele presentar incompatibilidades
con otros sistemas operativos, e
incluso con versiones anteriores
del mismo. Sólo lee y escribe sus
propios sistemas de archivos.
Tabla 3. Tabla Comparativa de las PlataformasAutor: Mario Castellanos
Fuente: http://tecnoblogy.wordpress.com/2006/12/18/comparativa-windows-vs-linux/
Después del análisis anterior se pudo establecer que Linux es mejor debido a que es
libre, se puede tener programas gratis, posee una fuerte seguridad, es compatible con
otros sistemas y con otros programas.
12
2. CAPITULO II.
2.1.Metodología de Investigación
La Metodología estudia la forma de proceder y las técnicas que el investigador puede
emplear.
En lo referente al diseño de investigación, existen varios tipos de clasificaciones
acerca del tipo de diseño, pero actualmente solo se emplean dos:
Tipo de diseño experimental
Tipo de diseño no experimental
El diseño de investigación empleado es el NO experimental ya que en el proyecto no
hay manipulación de variables, la acción de las variables son tomadas de la realidad
y no se interviene en ello, así mismo es de tipo transaccional, ya que permite
recolectar datos en un único momento en el tiempo del tema investigado; así como a
partir de los datos se pueden ser obtenidos de otras fuentes disponibles.
2.2.Metodología de Desarrollo
Las metodologías de desarrollo de software son un conjunto de procedimientos,
técnicas y ayudas a la documentación para el desarrollo de productos software14.
Por lo general en el proceso de construcción de un sistema, se deben tener planteadas
las tareas a realizar, de manera ordenada y con un grupo de persona de manera
simultánea con el propósito de cumplir dichas tareas y estructurar cada una de sus
fases para el desarrollo.
La finalidad de una metodología de desarrollo se lo define de la siguiente manera:
• Adecuación: El sistema debe cumplir las expectativas del usuario.
• Mantenimiento: Facilidad de realizar cambios en el sistema.
• Fiabilidad: Capacidad de que un sistema funcione correctamente dentro de un
tiempo estimado.
14 Metodología Desarrollo. Obtenido desde http://es.scribd.com/doc/12983329/Metodologia-de-Desarrollo-de-Software
13
• Corrección: Presencia de defectos mínima.
•Eficiencia: Capacidad de ejecutar utilizando el mínimo de recursos necesaria.
El presente proyecto hace necesario para su desarrollo la utilización de metodologías.
En primera instancia se requiere de una metodología general para el desarrollo de
proyectos, para lo cual mencionamos las más comunes utilizadas al momento:
Metodología XP (Programación Extrema)15.- Esta basado orientado directamente
al objetivo del proyecto, basándose para esto en las relaciones interpersonales y en la
velocidad de reacción para la implementación y para los cambios que puedan
surgir durante el desarrollo del proceso. Utiliza historias de uso en la cual los
usuarios y los desarrolladores establecen escenarios claves del funcionamiento
del software.
Metodología RUP16.- Este es uno de los procesos más generales que existe, está
enfocado a cualquier tipo de proyecto así no sea de software, se basa en la
documentación generada en cada uno de sus cuatro fases:
Inicio
Elaboración
Construcción
Transición
Cumpliendo con los siguientes principios:
Balancear Prioridades
Colaboración entre grupos
Demostrar valor Iterativo
RUP se basa en casos de uso para describir lo que se tiene y lo que se espera del
software, está muy orientado a la arquitectura del sistema a implementarse,
documentándose de la mejor manera, basándose en UML (Unified Modeling
Language - Lenguaje de Modelado Unificado).
15 Metodología XP, Obtenido el 12 de julio del 2014 desdehttp://es.slideshare.net/Piskamen/metodologa-xp.16 Metodología RUP, Obtenido el 12 de julio del 2014 desdehttp://es.slideshare.net/cortesalvarez/metodologa-rup.
14
Metodología CASE.- Plantea el uso de una secuencia de procesos de manera
más detallada a diferencia de las otras metodologías. En cada una de las etapas se
describen los objetivos a seguir, descripción exhaustiva de la etapa, lista de tareas a
realizar y factores críticos.
Metodología MSF17.- El Microsoft Solutions Framework proporciona un
sistema de modelos, principios, y pautas para dar soluciones a empresas que
diseñan y desarrollan de una manera que se asegure de que todos los elementos
de un proyecto, tales como gente, procesos, y herramientas, puedan ser
manejados con éxito. Se basa en las etapas características del modelo de cascada, y
las del modelo espiral.
Para la elección de la metodología se realizó un análisis, considerando los siguientes
criterios:
Antecedentes.- Se refiere a trabajos publicados y desarrollados en base a la
metodología en proyectos anteriores.
Disponibilidad.- Se refiere a la disponibilidad y fácil acceso a la información
relevante.
Conocimientos.- Si se tiene conocimiento de la metodología en base a
experiencias.
Orientación a la investigación.- Si la metodología es orientada a la
aplicación e investigación para el desarrollo del proyecto en general.
Escalabilidad.- Si se pueden generar equipos de trabajo más grandes o
realizar proyectos de mayor complejidad.
Flexibilidad.- Se refiere a si la metodología es flexible a cualquier
eventualidad es decir se adapta a cambios que se presenten.
De las metodologías mencionadas anteriormente; se ha establecido un cuadro
comparativo, tal como muestra en el siguiente cuadro:
17 Metodología MSF, Obtenida el 12 de julio del 2014 desdehttp://es.slideshare.net/bebeyom/metodologia-msf-4861508.
15
Tabla 4. Tabla de Criterio para selección de MetodologíaAutor: Tesistas Sistema Biométrico
Fuente: Tesis Sistema Biométrico para la conservación y recuperación en peligro de extinción de la especie Surien el Centro de Rescate del Proyecto Especial Binacional Lago Titicaca
Tomando la siguiente Escala de Valoración:
ESCALA DE VALORACION
Totalmente en desacuerdo 1En desacuerdo 2Ni de acuerdo, ni en desacuerdo 3De acuerdo 4Totalmente de acuerdo 5
Tabla 5. Escala de ValoraciónAutor: Tesistas Sistema Biométrico
Fuente: Tesis Sistema Biométrico para la conservación y recuperación en peligro de extinción de la especie Suri
en el Centro de Rescate del Proyecto Especial Binacional Lago Titicaca
Se ha considerado como metodología de desarrollo que se ajusta a las necesidadesdel tema de tesis a desarrollar y en base a la tabla 4, es la METODOLOGÍA RUP.
2.3.Metodología RUP
En definitiva el RUP es una metodología de desarrollo de software que intenta
integrar todos los aspectos a tener en cuenta durante todo el ciclo de vida del
software, con el objetivo de hacer abarcables tanto pequeños como grandes proyectos
software.
Cada etapa de RUP itera sobre 5 flujos de trabajo que son:
Requisitos
Averiguar lo que el sistema debe hacer.
Análisis
Conseguir una comprensión más precisa de los requisitos.
16
Diseño
Comprensión de los requisitos no funcionales y adaptación de los requisitos
funcionales para su implementación.
Implementación
Implementación de clases y pruebas de componentes individuales.
Pruebas
Planificar, diseñar y realizar las pruebas de integración y de sistemas.
2.4.Fases de la Metodología RUP
El ciclo de vida del RUP, como se conoce al trazado de las actividades de desarrollo
en el tiempo, está dividido en cuatro fases: inicio, elaboración, construcción y
transición.
En términos de habilidades el RUP está dividido en principios clave. Cada uno de
éstos corresponde a distintos aspectos de desarrollo de software.
Se aplicara este método al presente proyecto, en la que en cada fase se explicara.
2.4.1. Fase de Inicio
Se desarrolla una descripción del producto final, en esta fase se presenta la lógica del
negocio, con el fin de lograr que el equipo tenga claro los objetivos. De
manera general el objetivo es comprender lo que se va a hacer determinando la
visión.
En esta fase se pretende responder algunas preguntas tales como:
¿Cuál es el objetivo?, ¿Es factible?, ¿Lo construimos o lo compramos?,
¿Cuánto va a costar?
Los objetivos de esta fase son:
• Define los objetivos del proyecto.
• Define la funcionalidad y capacidades del producto.
• Establecer el ámbito del proyecto y sus límites.
17
• Estimar el coste en recursos y tiempo de todo el proyecto.
• Estimar los riesgos, las fuentes de incertidumbre.
ENTREGABLES FASE DE ANALISIS Y PLANIFICACIÓN
En la fase de inicio aplicado al proyecto, tomaremos en cuenta la toma de
requerimientos (funcionales y/o no funcionales), de manera general el
funcionamiento que deberá tener el sistema. (Ver anexo A)
Adicionalmente el alcance, las limitaciones y algunos requerimientos se las vio de
manera detallada en el capítulo anterior al igual que el glosario de términos se verá
en capítulos posteriores.
2.4.2. Fase de Elaboración
En ésta fase se especifica el proceso, los actores, los casos de uso, es decir, se analiza
el planteamiento del problema diseñando una arquitectura con la cual se va a utilizar
y el modelo de entidad relación.
La fase de elaboración comprende la construcción de un prototipo con la arquitectura
planteada el cual ira evolucionando hasta convertirse en el producto final.
Los objetivos / productos de esta fase son:
• Descripción del proceso.
Se detalla la manera de como se está manejando actual el proceso de gestión de las
tesis de grado.
• Diagrama Lógico del Proceso.
El diagrama nos permite documentar gráficamente la forma en que los datos se
mueven a través del sistema, incluyendo entradas, procesamiento y salida de los
datos.
Para nuestro caso tenemos el siguiente ejemplo:
18
Figura 2. Ejemplo de Diagrama lógico del proceso de Gestión de Tesis
19
• Actores del Proceso.
Los actores son personas, sistemas o dispositivos que interactúa con el sistema,
iniciando, recibiendo los resultados o participando en alguna de las acciones de un
caso de uso. Por lo general representa un rol, por ejemplo: administrador,
Secretario(a) de la Dirección de Carrera, investigador, etc.
Proceso:
Secretario(a) de la Dirección de Carrera
Iniciar el Proceso.
Asignar investigador y/o revisores,
tutor.
Actualizar el estado, y parámetros del
proceso.
Figura 3. Representación Proceso.Autor: Mario Castellanos
Fuente: Tesista
Representación UML18:
Se usa el elemento Actor de UML.
Figura 4. Representación ActorFuente: http://www.omg.org/spec/UML/2.1.2/Superstructure/PDF
• Definición y diagramas de los casos de uso.
Los casos de usos son representaciones de los requerimientos funcionales del sistema
o de un proceso del negocio que se implementa en el sistema de software.
Representación UML:
Se usa el mismo elemento Caso de uso de UML
18 UML Lenguaje Unificado de Modelado, obtenido el 12 de julio del 2014 desdehttp://www.omg.org/spec/UML/2.1.2/Superstructure/PDF
20
Figura 5. Representación Caso de Uso
Fuente: http://www.omg.org/spec/UML/2.1.2/Superstructure/PDF
Ejemplo definición Caso de uso (Administración del sistema)
Caso de Uso CU_001Descripción Administración del SistemaActores AdministradorPre – Condición 1. Para que inicie el correcto funcionamiento del sistema se
deben realizar las siguientes acciones en la base de datos:a. Crear un usuario, con los datos de la persona designadapor la Facultad para que cuente con el Rol deAdministrador.b. Crear un rol, en la tabla de Roles.2. En la Tabla Usuario_Roles, asignar el código de usuarioy rol.3. Para ingresar los datos del Usuario es necesario tener unregistro en la tabla Departamento tomando en cuenta adonde pertenece el usuario designado para ser elAdministrador del Sistema.4. En la tabla Departamento se debe llenar un solo campo:a. Nombre.
Tabla 6 .Ejemplo Caso Uso (Administración del sistema)Autor: Mario Castellanos
Fuente: Tesista
Ejemplo diagrama Caso de uso (Administración del sistema)
Figura 6. Ejemplo diagrama caso de uso (Administración del sistema)Autor: Mario Castellanos
Fuente: Tesista
21
• Diagramas de secuencia.
El diagrama de secuencia permite mostrar la forma en que los objetos se comunican
entre sí al transcurrir el tiempo.
Representación UML:
Figura 7. Representación Diagrama de Secuencia
Fuente: http://www.omg.org/spec/UML/2.1.2/Superstructure/PDF
Ejemplo Diagrama de Secuencia
Figura 8. Ejemplo Diagrama de SecuenciaAutor: Mario Castellanos
Fuente: Tesista
22
• Diseño de la Base de Datos.
Previendo que la información del sistema será soportada por una base de datos
relacional, este modelo describe la representación lógica de los datos, de acuerdo con
el enfoque para modelado relacional de datos.
Representación UML:
Figura 9. Representación Base de datos
Ejemplo Base de Datos:
FK_ESCUELA_REFERENCE_FACULTAD
FK_CARRERA_REFERENCE_ESCUELA
FK_ESTUDI_C_REFERENCE_CARRERA
FK_ESTUDI_C_REFERENCE_ESTUDIAN
FK_CARRERA__REFERENCE_CARRERA
FK_CARRERA__REFERENCE_PROFESOR
FK_EMPLEADO_REFERENCE_CARRERA
FK_ACCESO_REFERENCE_PROFESOR
FK_ACCESO_REFERENCE_EMPLEADO
FK_ACCESO_REFERENCE_ESTUDIAN
FK_ACCESO_REFERENCE_TIPO_PER
FK_ACCESO_R_REFERENCE_ACCESO
FK_PERMISOS_REFERENCE_FUNCIONE
FK_PERMISOS_REFERENCE_ROLES
FK_ACCESO_R_REFERENCE_ROLES
FK_DENUNCIA_REFERENCE_ESTUDIAN
FK_DENUNCIA_REFERENCE_TESIS
FK_TESIS_REFERENCE_ESTADO
FK_TUTORIAS_REFERENCE_TESIS
FK_PROF_TES_REFERENCE_PROFESOR
FK_PROF_TES_REFERENCE_TESIS
FK_PROF_TES_REFERENCE_ROL_PROF
FK_PROFESOR_REFERENCE_AREA_ACA
FACULTADID_FACULTADFACULTAD
SERIALVARCHAR(50)
<pk>
ESCUELA
ID_ESCUELAESCUELAID_FACULTAD...
SERIALVARCHAR(50)INT4
<pk>
<fk>
CARRERA
ID_CARRERACARRERAID_ESCUELA...
SERIALVARCHAR(50)INT4
<pk>
<fk>
ESTUDIANTE
CEDULANOMBRESAPELLIDOSMAILFECHA_EGRESOMALLA_COMPLETA...
VARCHAR(13)VARCHAR(100)VARCHAR(100)VARCHAR(70)DATECHAR(1)
<pk>
ESTUDI_CARRER
ID_ESTU_CARRID_CARRERACEDULA...
SERIALINT4VARCHAR(13)
<pk><fk1><fk2>
EMPLEADOS
CEDULA_EMPID_CARRERANOMBRE_EMPAPELLIDOS_EMPMAIL_EMP...
VARCHAR(13)INT4VARCHAR(255)VARCHAR(255)VARCHAR(70)
<pk><fk>
CARRERA_PROFE
ID_CARR_REVID_CARRERACEDULA_PROF...
SERIALINT4VARCHAR(13)
<pk><fk1><fk2>
PROFESORES
CEDULA_PROFNOMBRE_PROFAPELLIDOS_PROFMAIL_PROFID_AREA...
VARCHAR(13)VARCHAR(50)VARCHAR(50)VARCHAR(50)INT4
<pk>
<fk>
ACCESO
ID_ACCESOUSUARIOCLAVEESTADOCEDULACEDULA_EMPCEDULA_PROFID_TIPO...
SERIALVARCHAR(50)VARCHAR(50)VARCHAR(50)VARCHAR(13)VARCHAR(13)VARCHAR(13)INT4
<pk>
<fk3><fk2><fk1><fk4>
TIPO_PERSONA
ID_TIPOTIPO
SERIALVARCHAR(70)
<pk>
ACCESO_ROL
ID_ACCES_ROLID_ACCESOID_ROLESTADO...
SERIALINT4INT4VARCHAR(1)
<pk><fk1><fk2>
ROLES
ID_ROLROL
SERIALVARCHAR(50)
PERMISOS
ID_PERMISOID_FUNCIONID_ROLESTADO...
SERIALVARCHAR(20)INT4VARCHAR(1)
<pk><fk1><fk2>
FUNCIONES
ID_FUNCIONDESCRIPCION
VARCHAR(20)VARCHAR(200)
<pk>
PARAMETROS
ID_PARAMETROPARAMETROVALOR...
SERIALVARCHAR(50)VARCHAR(50)
<pk>
AD_INGRESOS
USUARIOFECHA_INGRESOHORA_INGRESOEXITOMOTIVO...
VARCHAR(50)DATETIMESTAMP WITH TIME ZONEVARCHAR(1)VARCHAR(150)
<pk><pk><pk><pk><pk>
ESTADO
ID_ESTADOESTADO
SERIALVARCHAR(50)
<pk>
DENUNCIANTE_TESIS
ID_DENUN_TESISMATRICULAENTREGA_SOLICITUDENTREGA_DOCUMENTACIONCEDULAID_TESIS...
SERIALINT4CHAR(1)CHAR(1)VARCHAR(13)INT4
<pk>
<fk1><fk2>
TESIS
ID_TESISTITULONUMERO_TRAMITENUMERO_OFICIOFECHA_ENTREGAFECHA_APROBACIONFECHA_NEGACIONFECHA_ASIGNACION_REVFECHA_ASIGNACION_TUTPROMEDIO_PROMOCIONNOTA_ESCRITONOTA_ORALNOTA_FINALHORASTOTAL_TUTORIAID_ESTADO...
SERIALVARCHAR(500)INT4INT4TIMESTAMPTIMESTAMPTIMESTAMPTIMESTAMPTIMESTAMPDECIMAL(4,2)DECIMAL(4,2)DECIMAL(4,2)DECIMAL(4,2)INT4INT4
<pk>
<fk>
TUTORIAS_TESIS
ID_TUTORIASID_TESISTIEMPO_REVISIONFECHA_REVISIONFECHA_PROX_REVISIONRECOMENDACIONESOBSERVACIONES
SERIALINT4DECIMAL(4,2)DATEDATEVARCHAR(255)VARCHAR(255)
<pk><fk>
PROF_TESIS
ID_PROF_TESCEDULA_PROFID_TESISID_ROL_PROF...
SERIALVARCHAR(13)INT4INT4
<pk><fk1><fk2><fk3>
ROL_PROFESOR_TESIS
ID_ROL_PROFROL_PROF
SERIALVARCHAR(50)
<pk>
AREA_ACADEMICA
ID_AREAAREA_ACADEMICO
SERIALVARCHAR(50)
<pk>
Figura 10. Ejemplo de Base de Datos (Abstracto)Autor: Mario Castellanos
Fuente: Tesista
23
2.4.3. Construcción
Se basa en la elaboración de un producto totalmente operativo de manera
incremental. Se redefine su análisis y diseño y se procede a su implantación y
pruebas. Todos los componentes, requisitos y características deben ser
implementados y probados para obtener así una versión aceptable del producto.
En esta fase se realiza una pequeña cascada para cada ciclo, se realizan tantas
iteraciones hasta que se termine la nueva implementación del producto.
Se definen los siguientes objetivos:
• Conseguir un producto de calidad reduciendo los riesgos.
• Obtención de versiones funcionales.
Los resultados de la fase de elaboración deben ser:
• Modelos Completos
• Manual Inicial de Usuario (con suficiente detalle)
• Prototipo Operacional – beta
En el presente proyecto de titulación se considerarán como entregables el Manual de
usuario y técnico que contendrá un conjunto de documentos y facilidades de uso del
sistema, Casos de usos completos, el sistema estable de acuerdo a los requerimientos
establecidos en las fases anteriores.
2.4.4. Transición
En esta última fase se entrega al usuario el producto final. Para esto en necesario
desarrollar versiones actualizadas del producto, adicionalmente se realizan las
configuraciones respectivas, la instalación para así obtener un sistema completo en
todos los sentidos tanto tecnológico como de usuario.
Se definen los siguientes objetivos:
• El producto final trabaje acorde con los requerimientos del usuario.
24
• Establecer la armonía entre el sistema y el usuario haciendo interfaces amigables
para el mismo.
Los resultados de la fase de elaboración deben ser:
• Prototipo Operacional final
• Documentación Completa
El sistema tendrá como entregables en la parte final el sistema operacional que
contará con los ficheros fuente y ejecutables del producto, los manuales de usuarios y
técnicos completos.
25
3. CAPITULO III.
3.1.FASE DE INICIO
3.1.1.Descripción del proceso
El proceso que se viene llevando a cabo para la Gestión de las Tesis es el siguiente:
La gestión empieza con la presentación del plan de tesis por parte del estudiante,
donde la secretaria procederá a ingresar los datos del plan, considerando que cumpla
el estudiante con los requerimientos establecidos, aquí considerar el caso que un
estudiante sobrepase los dos años de egresado ya que si esto se cumple tendrá que
tomar un curso de actualización, esto se puede controlar un check.
Luego el Director de Escuela será el encargado indicar si el tema presentado por el
estudiante es viable (Aprobado), de serlo se asigna a un docente para que sea el
investigador encargado de revisar el plan de tesis. La secretaria será la encargada de
revisar de que el oficio (Plantilla) que se enviará al investigador, se encuentre bien
redactado. Esta notificación (archivo PDF) les llegara al investigador; los cuales
tendrán 15 días calendario para emitir un informe o a su vez solicitar algún cambio
sobre el plan de tesis, el estudiante para realizar los cambios solicitado por un revisor
tiene también 15 días para realizarlo. Todo esto se tiene que mantener informado
tanto a los estudiantes como revisores vía mail. Si después de todos los cambios
solicitados aun no es aprobado definitivamente, el estudiante puede presentar otro
plan de tesis.
En caso de que sea favorable la respuesta del investigador, se enviará una
notificación a la secretaria y también al estudiante con el Visto Bueno sobre el Plan
de Tesis. Luego la secretaria será la que continúe el flujo enviando al Director de
Escuela con el fin de que asigne un tutor del proyecto de tesis.
Luego la secretaria será la encargada de revisar de que el oficio (Plantilla) que se
enviará al Tutor, se encuentre bien redactado. Esta notificación (archivo PDF) le
llegara al tutor; indicando todo lo que él debe hacer como tutor. Una de los puntos
indica que las horas de tutoría deben ser registradas en un total de 60 horas.
Además al momento de que el tutor revise la notificación de asignación, esto
permitirá al estudiante que se habilite un formulario en donde él ya pueda subir su
primera versión del documento de tesis. Aquí existirá una acción repetitiva entre
tutor y estudiante, hasta que el tutor indique que se ha completado correctamente.
26
En caso de que el TUTOR considere que la tutoría haya culminado. Éste emitirá un
Certificado de Idoneidad, que en el proceso será notificado tanto a la Secretaria como
al Estudiante.
Con esto el estudiante podrá solicitar un Tribunal para Calificación del Documento
de Tesis (Plantilla), que será receptada por la Secretaria, con el fin de Notificar al
Director, una vez que el tribunal emita un informe favorable se continua, caso
contrario el estudiante tiene un plazo máximo de 30 días para realizar las
modificaciones respectivas.
Una vez asentada la nota del Documento de Grado, el estudiante está listo para
solicitar (Plantilla) TRIBUNAL DE GRADO ORAL.
La solicitud será receptada por la secretaria con el fin de Notificar al Director. Luego
él será el encargado de asignar el TRIBUNAL DE GRADO ORAL, luego la
secretaria será la encargada de revisar que el oficio (Plantilla) que se enviará al
TRIBUNAL DE GRADO ORAL del Proyecto de Tesis, se encuentre bien redactado.
Esta notificación (archivo PDF) le llegará a los miembros del tribunal de grado oral
indicando la fecha y la hora.
Luego llega el día de la defensa con el TRIBUNAL DE GRADO ORAL, según yo lo
veo esto no es automatizable en el sentido de que los docentes no van estar en ese
momento con una computadora ingresando la nota. Lo que se suele hacer es un acta
que luego es firmada por el Secretario Abogado.
La nota final de graduación es el resultado del promedio de las siguientes
calificaciones:
-Promedio de promociones de carrera.
-Notas de trabajo escrito de grado.
-Nota de exposición oral.
Observaciones:
En caso de que el estudiante no aprobare el grado oral, podrá presentarse a una
segunda oportunidad en plazo de hasta 6 meses, previa solicitud dirigida a Director
de Carrera. El promedio de Promoción será ingresada manualmente.
27
3.1.2. Diagrama Lógico del proceso
Figura 11. Diagrama Lógico del ProcesoAutor: Mario Castellanos
Fuente: Tesista
28
3.1.3. Actores del proceso
En función del planteamiento del proceso, se definen actores que se presentan
a continuación:
4.
ACTOR FUNCION
Administrador Creación de roles, administrador
Secretario(a) de la Dirección de Carrera
Iniciar el Proceso.
Asignar investigador y/o revisores,
tutor.
Actualizar el estado, y parámetros del
proceso.
Investigador/Revisor
Recibir notificaciones de la Dirección
de Carrera.
Revisar el plan de tesis y emitir el
informe con sus respectivas
observaciones y/o recomendaciones.
Aprobación del plan de tesis.
Tutor
Recibir notificaciones de la
Dirección de Carrera.
Calificación de la tesis.
Emitir un informe.
Estudiante
Subir el plan de tesis.
Recibir notificaciones de la
Dirección de Carrera.
Tribunal Calificador
Recibir notificación de Dirección
Calificar la tesis
Emitir Informe
29
Tribunal Grado Oral
Recibir notificación de Dirección
Calificar defensa Oral
Emitir un informe
Secretaria Decanato
Comprobar requerimientos para
graduación.
Registrar si el estudiante aprobó la
defensa oral.
Secretaria Abogada Registra la nota de la defensa oral.
Registra el número de folio.
Tabla 5. Tabla de Actores del ProcesoAutor: Mario Castellanos
Fuente: Tesista
3.1.4. Modelado del Negocio
La Facultad de Jurisprudencia de la Universidad Central del Ecuador tomada como
referencia para el proyecto de desarrollo software consta de varios departamentos
que contribuyen con cada una de sus funciones a la meta de la Facultad de
Jurisprudencia.
En el siguiente diagrama se representan los diferentes subsistemas en los que se ha
dividido la Facultad de Jurisprudencia a nivel de abstracción:
30
5.Figura 12. Diagrama Abstracto de los Departamentos
Autor: Mario CastellanosFuente: Tesista
3.1.5. Modelo de Casos de Uso y Diagramas de secuencia del Negocio
1. CASO DE USO: Administración del Sistema
Definición:
Caso de Uso CU_001
Descripción Administración del Sistema
Actores Administrador
Pre – Condición 1. Para que inicie el correcto funcionamiento del sistema se
deben realizar las siguientes acciones en la base de datos:
a. Crear un usuario, con los datos de la persona designada
por la Facultad para que cuente con el Rol de
Administrador.
b. Crear un rol, en la tabla de Roles.
2. En la Tabla Usuario_Roles, asignar el código de usuario
y rol.
3. Para ingresar los datos del Usuario es necesario tener un
registro en la tabla Departamento tomando en cuenta a
donde pertenece el usuario designado para ser el
31
Administrador del Sistema.
4. En la tabla Departamento se debe llenar un solo campo:
a. Nombre.
Tabla 7. Definición del Caso de Uso: Administración del SistemaAutor: Mario Castellanos
Fuente: Tesista
Representación:
Figura 13. Caso de Uso: Administración del SistemaAutor: Mario Castellanos
Fuente: Tesista
Diagrama dge Secuencia:
32
Figura 14. Diagrama de Secuencia: Administración del SistemaAutor: Mario Castellanos
Fuente: Tesista
2. CASO DE USO: Iniciar Proceso
Definición:
Caso de Uso CU_002Descripción Iniciar ProcesoActores Secretaria(o)Pre – Condición El usuario a ingresar debe tener el permiso de acceso y el
rol respectivo, contrario se negará su ingreso.Flujo Normal 1. El usuario (Secretaria), ingresa al sistema por medio de
la interfaz gráfica.2. El sistema presenta la interfaz de login en donde sesolicita los siguientes datos:
Usuario
Contraseña3. El usuario ingresa los datos solicitados.4. Presiona el botón Acceder.5. El sistema validará la información. ingresada6. El sistema presenta las opciones que posee habilitadas
para su rol.7. El usuario verifica los requerimientos necesarios.
33
8. Presiona el botón Iniciar Proceso (Crear nuevo Registrode Plan).
9. Presentación de los campos en blanco.10. Ingreso de la información del estudiante y del plan de
tesis solicitada.11. Validación de la información.12. Presione el botón Guardar.13. Notificación de carga del plan al correo al estudiante.
Flujo Alternativo Información ingresada no correcta:1. Los datos de usuario y contraseña no coinciden con los
datos de la base de datos-2. El usuario no tiene el permiso de acceso o rol necesario.3. La información ingresada en el formulario no son
correctos (validación de valores).4. Cancelación del proceso
Tabla 8. Definición Caso de Uso: Iniciar ProcesoAutor: Mario Castellanos
Fuente: Tesista
Representación:
Figura 15. Caso de Uso: Iniciar ProcesoAutor: Mario Castellanos
Fuente: Tesista
34
Diagrama de Secuencia:
Figura 16. Diagrama de Secuencia: Iniciar ProcesoAutor: Mario Castellanos
Fuente: Tesista
3. CASO DE USO: Subir Archivo
Definición:
Caso de Uso CU_003Descripción Subir archivoActores EstudiantePre – Condición Haber recibido la notificación de subida del archivo al
correo.Flujo Normal 1. Notificación al correo del estudiante.
2. Ingresar al sistema por medio de la interfaz gráfica.3. Ingreso de usuario y contraseña.4. Validación de usuario y contraseña con la base de datos5. Presentación de las opciones del estudiante.6. Selección del archivo a subir.7. Carga del archivo.
Flujo Alternativo La información ingresada incorrecta:1.El usuario y/o contraseña incorrectos.
Usuario no conste en la base.Archivo a subir en un formato incorrecto.
Post – Condición Notificación de carga exitosa al correo.
35
Tabla 9. Definición Caso de Uso: Subir ArchivoAutor: Mario Castellanos
Fuente: Tesista
Representación:
Figura 17. Caso de Uso: Subir archivoAutor: Mario Castellanos
Fuente: Tesista
Diagrama de Secuencia:
Figura 18. Diagrama de Secuencia: Subir ArchivoAutor: Mario Castellanos
Fuente: Tesista
36
4. CASO DE USO: Pre revisión plan de tesis
Definición:
Caso de Uso CU_004
Descripción Pre Revisión plan de Tesis
Actores Investigadores
Pre – Condición Carga del archivo por parte del estudiante.
Ingreso del investigador/revisor al sistema.
Flujo Normal El investigador/revisor se descarga el archivo subido por el
estudiante y revisa el plan de tesis.
El revisor aprueba o recha el plan de tesis.
Si aprueba elabora una solicitud de aprobación del
plan de tesis.
Si rechaza se da una notificación al estudiante.
Tabla 10. Pre revisión plan de tesisAutor: Mario Castellanos
Fuente: Tesista
Representación:
Figura 19. Caso de Uso: Pre revisión plan tesisAutor: Mario Castellanos
Fuente: Tesista
37
Diagrama de Secuencia:
Figura 20. Diagrama de Secuencia: Pre Revisión Plan TesisAutor: Mario Castellanos
Fuente: Tesista
5.CASO DE USO: Tutoría Tesis
Definición:
Descripción CU_005
Actores Estudiante, Tutor
Pre – Condición Aprobación del plan de tesis
Flujo Normal El estudiante sube el archivo de a ser revisado.
El tutor se descarga el archivo y revisa.
El tutor realiza las correcciones respectivas y sube el
archivo.
Este proceso se repite hasta que el tutor de por terminado la
tesis.
Flujo Alternativo
Post – Condición
Tabla 11. Definición Caso de Uso: Tutoría TesisAutor: Mario Castellanos
Fuente: Tesista
38
Representación:
Figura 21. Tutoría de TesisAutor: Mario Castellanos
Fuente: Tesista
Diagrama de Secuencia
Figura 22. Diagrama de Secuencia Tutoría TesisAutor: Mario Castellanos
Fuente: Tesista
39
3.2. FASE DE ELABORACIÓN
3.2.1.Construcción del Modelo de Datos del Sistema
FK_ESCUELA_REFERENCE_FACULTAD
FK_CARRERA_REFERENCE_ESCUELA
FK_ESTUDI_C_REFERENCE_CARRERA
FK_ESTUDI_C_REFERENCE_ESTUDIAN
FK_CARRERA__REFERENCE_CARRERA
FK_CARRERA__REFERENCE_PROFESOR
FK_EMPLEADO_REFERENCE_CARRERA
FK_ACCESO_REFERENCE_PROFESOR
FK_ACCESO_REFERENCE_EMPLEADO
FK_ACCESO_REFERENCE_ESTUDIAN
FK_ACCESO_REFERENCE_TIPO_PER
FK_ACCESO_R_REFERENCE_ACCESO
FK_PERMISOS_REFERENCE_FUNCIONE
FK_PERMISOS_REFERENCE_ROLES
FK_ACCESO_R_REFERENCE_ROLES
FK_DENUNCIA_REFERENCE_ESTUDIAN
FK_DENUNCIA_REFERENCE_TESIS
FK_TESIS_REFERENCE_ESTADO
FK_TUTORIAS_REFERENCE_TESIS
FK_PROF_TES_REFERENCE_PROFESOR
FK_PROF_TES_REFERENCE_TESIS
FK_PROF_TES_REFERENCE_ROL_PROF
FK_PROFESOR_REFERENCE_AREA_ACA
FK_TESIS_REFERENCE_PROCESOS
FK_DOCUMENT_REFERENCE_CARRERA
FACULTAD
ID_FACULTADFACULTAD
SERIALVARCHAR(50)
<pk>
ESCUELA
ID_ESCUELAESCUELAID_FACULTAD...
SERIALVARCHAR(50)INT4
<pk>
<fk>
CARRERA
ID_CARRERACARRERAID_ESCUELA...
SERIALVARCHAR(50)INT4
<pk>
<fk>
ESTUDIANTE
CEDULANOMBRESAPELLIDOSMAILFECHA_EGRESOMALLA_COMPLETA...
VARCHAR(13)VARCHAR(100)VARCHAR(100)VARCHAR(70)DATECHAR(1)
<pk>
ESTUDI_CARRER
ID_ESTU_CARRID_CARRERACEDULA...
SERIALINT4VARCHAR(13)
<pk><fk1><fk2>
EMPLEADOS
CEDULA_EMPID_CARRERANOMBRE_EMPAPELLIDOS_EMPMAIL_EMP...
VARCHAR(13)INT4VARCHAR(255)VARCHAR(255)VARCHAR(70)
<pk><fk>
CARRERA_PROFE
ID_CARR_REVID_CARRERACEDULA_PROF...
SERIALINT4VARCHAR(13)
<pk><fk1><fk2>
PROFESORES
CEDULA_PROFNOMBRE_PROFAPELLIDOS_PROFMAIL_PROFID_AREASECUENCIAL...
VARCHAR(13)VARCHAR(50)VARCHAR(50)VARCHAR(50)INT4INT4
<pk>
<fk>
ACCESO
USUARIOCLAVEESTADOCEDULACEDULA_EMPCEDULA_PROFID_TIPO...
VARCHAR(50)VARCHAR(50)VARCHAR(50)VARCHAR(13)VARCHAR(13)VARCHAR(13)INT4
<pk>
<fk3><fk2><fk1><fk4>
TIPO_PERSONA
ID_TIPOTIPO
SERIALVARCHAR(70)
<pk>
ACCESO_ROL
ID_ACCES_ROLID_ROLUSUARIOESTADO...
SERIALINT4VARCHAR(50)VARCHAR(1)
<pk><fk2><fk1>
ROLES
ID_ROLROLDESCRIPCION
SERIALVARCHAR(50)VARCHAR(50)
<pk>
PERMISOS
ID_PERMISOID_FUNCIONID_ROLESTADO...
SERIALVARCHAR(20)INT4VARCHAR(1)
<pk><fk1><fk2>
FUNCIONES
ID_FUNCIONDESCRIPCION
VARCHAR(20)VARCHAR(200)
<pk>
PARAMETROS
ID_PARAMETROPARAMETROVALOR...
SERIALVARCHAR(50)VARCHAR(50)
<pk>AD_INGRESOS
USUARIOFECHA_INGRESOHORA_INGRESOEXITOMOTIVO...
VARCHAR(50)DATETIMESTAMP WITH TIME ZONEVARCHAR(1)VARCHAR(150)
<pk><pk><pk><pk><pk>
ESTADO
ID_ESTADOESTADO
SERIALVARCHAR(50)
<pk>
DENUNCIANTE_TESIS
ID_DENUN_TESISMATRICULAENTREGA_SOLICITUDENTREGA_DOCUMENTACIONCEDULAID_TESIS...
SERIALINT4VARCHAR(1)VARCHAR(1)VARCHAR(13)INT4
<pk>
<fk1><fk2>
TESIS
ID_TESISTITULODESCRIPCIONNUMERO_TRAMITENUMERO_OFICIOFECHA_ENTREGAFECHA_APROBACIONFECHA_VENCIMIENTOFECHA_NEGACIONFECHA_ASIGNACION_REVFECHA_ASIGNACION_TUTPROMEDIO_PROMOCIONNOTA_ESCRITONOTA_ORALNOTA_FINALHORASTOTAL_TUTORIAID_ESTADOID_PROCESO...
SERIALVARCHAR(500)VARCHAR(200)VARCHAR(50)VARCHAR(50)TIMESTAMPTIMESTAMPTIMESTAMPTIMESTAMPTIMESTAMPTIMESTAMPDECIMAL(4,2)DECIMAL(4,2)DECIMAL(4,2)DECIMAL(4,2)INT4INT4INT4
<pk>
<fk1><fk2>
TUTORIAS_TESIS
ID_TUTORIASID_TESISTIEMPO_REVISIONFECHA_REVISIONFECHA_PROX_REVISIONRECOMENDACIONESOBSERVACIONES
SERIALINT4DECIMAL(4,2)DATEDATEVARCHAR(255)VARCHAR(255)
<pk><fk>
PROF_TESIS
ID_PROF_TESCEDULA_PROFID_TESISID_ROL_PROFORDEN...
SERIALVARCHAR(13)INT4INT4INT4
<pk><fk1><fk2><fk3>
ROL_PROFESOR_TESIS
ID_ROL_PROFROL_PROF
SERIALVARCHAR(50)
<pk>
AREA_ACADEMICA
ID_AREAAREA_ACADEMICO
SERIALVARCHAR(50)
<pk>
REGISTRO_WEB
ID_REGISTROCEDULAGENERADOESTADO...
SERIALVARCHAR(13)VARCHAR(100)VARCHAR(1)
<pk>
DOCUMENTOS_TRAMITES
ID_DOC_TRAMDOCUMENTODEPARTAMENTOABREVIATURA_DOCSECUENCIAL_ACTUALID_CARRERA...
SERIALVARCHAR(20)VARCHAR(20)VARCHAR(10)INT4INT4
<pk>
<fk>
PROCESOS_UCE
IDUUIDPROCESOSUUIDINSTANCIAID_FACULTADESPACIOURL_ESPACIOTEMA...
SERIALVARCHAR(100)VARCHAR(100)INT4VARCHAR(100)VARCHAR(100)VARCHAR(100)
<pk>
AD_SECNOS
ID_SECNOSCARRERAAREAMAXPROFESORSEC_ACTUAL...
SERIALINT4INT4INT4INT4
<pk>
Figura 23. Modelo de Base de DatosAutor: Mario Castellanos
Fuente: Tesista
40
3.2.2.Construcción del Modelo Orientado a Objetos del Sistema
0..1
0..*
0..1
0..* 0..1
0..*
0..10..*
0..1
0..*
0..1
0..*
0..1
0..*
0..1
0..*
0..1
0..*
0..1 0..*
0..10..*
0..1 0..*
0..1 0..*
0..10..*
0..10..*
0..1
0..*
0..1 0..*
0..1
0..*
0..1
0..*
0..1
0..*
0..1
0..*0..1
0..*
0..1
0..*
0..1
0..*
0..1
0..*
FACULTAD
++
ID_FACULTADFACULTAD
: long: java.lang.String
ESCUELA
++
ID_ESCUELAESCUELA
: long: java.lang.String
CARRERA
++
ID_CARRERACARRERA
: long: java.lang.String
ESTUDIANTE++++++
CEDULANOMBRESAPELLIDOSMAILFECHA_EGRESOMALLA_COMPLETA
: java.lang.String: java.lang.String: java.lang.String: java.lang.String: java.util.Date: java.lang.String
ESTUDI_CARRER
+ ID_ESTU_CARR : long
EMPLEADOS
++++
CEDULA_EMPNOMBRE_EMPAPELLIDOS_EMPMAIL_EMP
: java.lang.String: java.lang.String: java.lang.String: java.lang.String
CARRERA_PROFE
+ ID_CARR_REV : long
PROFESORES
+++++
CEDULA_PROFNOMBRE_PROFAPELLIDOS_PROFMAIL_PROFSECUENCIAL
: java.lang.String: java.lang.String: java.lang.String: java.lang.String: int
ACCESO
+++
USUARIOCLAVEESTADO
: java.lang.String: java.lang.String: java.lang.String
TIPO_PERSONA
++
ID_TIPOTIPO
: long: java.lang.String
ACCESO_ROL
++
ID_ACCES_ROLESTADO
: long: java.lang.String
ROLES
+++
ID_ROLROLDESCRIPCION
: long: java.lang.String: java.lang.String
PERMISOS
++
ID_PERMISOESTADO
: long: java.lang.String
FUNCIONES
++
ID_FUNCIONDESCRIPCION
: java.lang.String: java.lang.String
PARAMETROS
+++
ID_PARAMETROPARAMETROVALOR
: long: java.lang.String: java.lang.String
AD_INGRESOS
+++++
USUARIOFECHA_INGRESOHORA_INGRESOEXITOMOTIVO
: java.lang.String: java.util.Date: java.util.Date: java.lang.String: java.lang.String
ESTADO
++
ID_ESTADOESTADO
: long: java.lang.String
DENUNCIANTE_TESIS
++++
ID_DENUN_TESISMATRICULAENTREGA_SOLICITUDENTREGA_DOCUMENTACION
: long: int: java.lang.String: java.lang.String
TESIS
++++++++++++++++
ID_TESISTITULODESCRIPCIONNUMERO_TRAMITENUMERO_OFICIOFECHA_ENTREGAFECHA_APROBACIONFECHA_VENCIMIENTOFECHA_NEGACIONFECHA_ASIGNACION_REVFECHA_ASIGNACION_TUTPROMEDIO_PROMOCIONNOTA_ESCRITONOTA_ORALNOTA_FINALHORASTOTAL_TUTORIA
: long: java.lang.String: java.lang.String: java.lang.String: java.lang.String: java.util.Date: java.util.Date: java.util.Date: java.util.Date: java.util.Date: java.util.Date: double: double: double: double: int
TUTORIAS_TESIS
++++++
ID_TUTORIASTIEMPO_REVISIONFECHA_REVISIONFECHA_PROX_REVISIONRECOMENDACIONESOBSERVACIONES
: long: double: java.util.Date: java.util.Date: java.lang.String: java.lang.String
PROF_TESIS
++
ID_PROF_TESORDEN
: long: int
ROL_PROFESOR_TESIS
++
ID_ROL_PROFROL_PROF
: long: java.lang.String
AREA_ACADEMICA
++
ID_AREAAREA_ACADEMICO
: long: java.lang.String
REGISTRO_WEB
++++
ID_REGISTROCEDULAGENERADOESTADO
: long: java.lang.String: java.lang.String: java.lang.String
DOCUMENTOS_TRAMITES
+++++
ID_DOC_TRAMDOCUMENTODEPARTAMENTOABREVIATURA_DOCSECUENCIAL_ACTUAL
: long: java.lang.String: java.lang.String: java.lang.String: int
PROCESOS_UCE
+++++++
IDUUIDPROCESOSUUIDINSTANCIAID_FACULTADESPACIOURL_ESPACIOTEMA
: long: java.lang.String: java.lang.String: int: java.lang.String: java.lang.String: java.lang.String
AD_SECNOS
+++++
ID_SECNOSCARRERAAREAMAXPROFESORSEC_ACTUAL
: long: int: int: int: int
Figura 24. Modelo Orientado a Objetos.Autor: Mario Castellanos
Fuente: Tesista
41
3.2.3. Modelo de Clases
<<EJBLocal>>admCarreraProfesor
+++++++++++++++
++
++
++
++++
++
end ()guardarCarreraProfesor ()nuevo ()begin ()destroy ()buscarCarreraProfesor ()setterCarreraProfesor (Object obj[])getIdFacultad ()setIdFacultad (int idFacultad)getIdCarrera ()setIdCarrera (int idCarrera)getIdEscuela ()setIdEscuela (int idEscuela)getListaFacultades ()setListaFacultades (List<SelectItemObj> listaFacultades)getListaEscuelas ()setListaEscuelas (List<SelectItemObj> listaEscuelas)getListaCarreras ()setListaCarreras (List<SelectItemObj> listaCarreras)getListaTabla ()setListaTabla (List<Object[]> l istaTabla)getIdProfesor ()setIdProfesor (String idProfesor)getCarreraProfe ()setCarreraProfe (CarreraProfe carreraProfe)getListaProfesores ()setListaProfesores (List<SelectItemObj> listaProfesores)...
: void: void: void: void: void: void: void: int: void: int: void: int: void: List<SelectItemObj>: void
: List<SelectItemObj>: void
: List<SelectItemObj>: void
: List<Object[]>: void
: String: void: CarreraProfe: void
: List<SelectItemObj>: void
<<EJBSession>>admCarreraProfesorBean
-***----------*****
logfacesMessagesidentitycredentialsidFacultadidCarreraidEscuelaidProfesorlistaFacultadeslistaEscuelaslistaCarreraslistaProfesoreslistaTablacarreraProfecarreraSrvescuelaSrvfacultadSrvprofesorSrvcarProfSrv
: Log: FacesMessages: Identity: Credentials: int: int: int: String: List<SelectItemObj>: List<SelectItemObj>: List<SelectItemObj>: List<SelectItemObj>: List<Object[]>: CarreraProfe: CarreraServicio: EscuelaServicio: FacultadServicio: ProfesoresServicio: CarreraProfesorServicio
= -1 = -1 = -1 = "-1"
= new ArrayList<SelectItemObj>()
+++++++++++++++
++
++
++
++++
++
<<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>>
<<Implement>><<Implement>>
<<Implement>><<Implement>>
<<Implement>><<Implement>>
<<Implement>><<Implement>><<Implement>><<Implement>>
<<Implement>><<Implement>>
begin ()destroy ()nuevo ()end ()guardarCarreraProfesor ()buscarCarreraProfesor ()setterCarreraProfesor (Object obj[])getIdFacultad ()setIdFacultad (int idFacultad)getIdCarrera ()setIdCarrera (int idCarrera)getIdEscuela ()setIdEscuela (int idEscuela)getListaFacultades ()setListaFacultades (List<SelectItemObj> listaFacultades)getListaEscuelas ()setListaEscuelas (List<SelectItemObj> listaEscuelas)getListaCarreras ()setListaCarreras (List<SelectItemObj> listaCarreras)getListaTabla ()setListaTabla (List<Object[]> l istaTabla)getIdProfesor ()setIdProfesor (String idProfesor)getCarreraProfe ()setCarreraProfe (CarreraProfe carreraProfe)getListaProfesores ()setListaProfesores (List<SelectItemObj> listaProfesores)...
: void: void: void: void: void: void: void: int: void: int: void: int: void: List<SelectItemObj>: void
: List<SelectItemObj>: void
: List<SelectItemObj>: void
: List<Object[]>: void
: String: void: CarreraProfe: void
: List<SelectItemObj>: void
<<EJBLocal>>admUsuario
+++++++++++
++++++
++++++++++
++
++
++
++++
end ()guardarUsuario ()nuevo ()begin ()destroy ()buscarUsuario ()setterUsuario (Object obj[])cambiarEstado (Object obj[])cargar ()getListaTabla ()setListaTabla (List<Object[]> l istaTabla)getIdTipoUser ()setIdTipoUser (int idTipoUser)getAcceso ()setAcceso (Acceso acceso)getListaTipoUser ()setListaTipoUser (List<SelectItemObj> listaTipoUser)getUsuario ()setUsuario (String usuario)getClave ()setClave (String clave)getIdEmpleado ()setIdEmpleado (String idEmpleado)getIdProfesor ()setIdProfesor (String idProfesor)getListaTipoUsuario ()setListaTipoUsuario (List<SelectItemObj> listaTipoUsuario)getListaEmpleados ()setListaEmpleados (List<SelectItemObj> listaEmpleados)getListaProfesores ()setListaProfesores (List<SelectItemObj> listaProfesores)isBandEstudiante ()setBandEstudiante (boolean bandEstudiante)isBandEmpleado ()setBandEmpleado (boolean bandEmpleado)isBandProfesor ()setBandProfesor (boolean bandProfesor)...
: void: void: void: void: void: void: void: void: void: List<Object[]>: void
: int: void: Acceso: void: List<SelectItemObj>: void
: String: void: String: void: String: void: String: void: List<SelectItemObj>: void
: List<SelectItemObj>: void
: List<SelectItemObj>: void
: boolean: void
: boolean: void: boolean: void
<<EJBSession>>admUsuarioBean
-**********-----------------
logfacesMessagesidentitycredentialsautSrvtpSrvemplSrvprofSrvmailparamSrvregistroSrvidTipoUseraccesolistaTipoUserlistaTablausuarioclaveidEmpleadoidProfesorlistaEmpleadoslistaProfesoreslistaTipoUsuariolistaUsuarioEstudianteslistaUsuarioEmpleadoslistaUsuarioProfesoresbandEstudiantebandEmpleadobandProfesor
: Log: FacesMessages: Identity: Credentials: AutenticadorServicio: TipoPersonaServicio: EmpleadosServicio: ProfesoresServicio: MailServicio: ParametrosServicio: RegistroWebServicio: int: Acceso: List<SelectItemObj>: List<Object[]>: String: String: String: String: List<SelectItemObj>: List<SelectItemObj>: List<SelectItemObj>: List<Object[]>: List<Object[]>: List<Object[]>: boolean: boolean: boolean
++++++
++++++
++++++
++++++++++
++
++
++
++++
<<Implement>><<Implement>><<Implement>><<Implement>><<Implement>>
<<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>>
<<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>>
<<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>>
<<Implement>><<Implement>>
<<Implement>><<Implement>>
<<Implement>><<Implement>>
<<Implement>><<Implement>><<Implement>><<Implement>>
begin ()destroy ()nuevo ()end ()cargar ()enviarCorreo (String valor, String usuario, String validador)guardarUsuario ()buscarUsuario ()setterUsuario (Object obj[])cambiarEstado (Object obj[])getListaTabla ()setListaTabla (List<Object[]> l istaTabla)getIdTipoUser ()setIdTipoUser (int idTipoUser)getAcceso ()setAcceso (Acceso acceso)getListaTipoUser ()setListaTipoUser (List<SelectItemObj> listaTipoUser)getUsuario ()setUsuario (String usuario)getClave ()setClave (String clave)getIdEmpleado ()setIdEmpleado (String idEmpleado)getIdProfesor ()setIdProfesor (String idProfesor)getListaTipoUsuario ()setListaTipoUsuario (List<SelectItemObj> listaTipoUsuario)getListaEmpleados ()setListaEmpleados (List<SelectItemObj> listaEmpleados)getListaProfesores ()setListaProfesores (List<SelectItemObj> listaProfesores)isBandEstudiante ()setBandEstudiante (boolean bandEstudiante)isBandEmpleado ()setBandEmpleado (boolean bandEmpleado)isBandProfesor ()setBandProfesor (boolean bandProfesor)...
: void: void: void: void: void: void
: void: void: void: void: List<Object[]>: void
: int: void: Acceso: void: List<SelectItemObj>: void
: String: void: String: void: String: void: String: void: List<SelectItemObj>: void
: List<SelectItemObj>: void
: List<SelectItemObj>: void
: boolean: void
: boolean: void: boolean: void
Figura 25. Diagrama de Clases (1)Autor: Mario Castellanos
Fuente: Tesista
42
<<EJBLocal>>admDocumentos
+++++++++++++
++
++
++++
++
++
++
end ()guardar ()nuevo ()begin ()destroy ()getIdFacultad ()setIdFacultad (int idFacultad)getIdCarrera ()setIdCarrera (int idCarrera)getIdEscuela ()setIdEscuela (int idEscuela)getListaFacultades ()setListaFacultades (List<SelectItemObj> listaFacultades)getListaEscuelas ()setListaEscuelas (List<SelectItemObj> listaEscuelas)getListaCarreras ()setListaCarreras (List<SelectItemObj> listaCarreras)getDocumento ()setDocumento (String documento)getAbreviaturaDoc ()setAbreviaturaDoc (String abreviaturaDoc)getSecuencialActual ()setSecuencialActual (int secuencialActual)getListaTabla ()setListaTabla (List<Object[]> l istaTabla)getDepartamento ()setDepartamento (String departamento)...
: void: void: void: void: void: int: void: int: void: int: void: List<SelectItemObj>: void
: List<SelectItemObj>: void
: List<SelectItemObj>: void
: String: void: String: void
: int: void
: List<Object[]>: void
: String: void
<<EJBSession>>admDocumentosBean
-***-----------****
logfacesMessagesidentitycredentialsidFacultadidCarreraidEscuelalistaFacultadeslistaEscuelaslistaCarreraslistaTabladocumentoabreviaturaDocsecuencialActualdepartamentocarreraSrvescuelaSrvfacultadSrvdocSrv
: Log: FacesMessages: Identity: Credentials: int: int: int: List<SelectItemObj>: List<SelectItemObj>: List<SelectItemObj>: List<Object[]>: String: String: int: String: CarreraServicio: EscuelaServicio: FacultadServicio: DocumentosServicio
= -1 = -1 = -1
+++++++++++++
++
++
++++
++
++
++
<<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>>
<<Implement>><<Implement>>
<<Implement>><<Implement>>
<<Implement>><<Implement>><<Implement>><<Implement>>
<<Implement>><<Implement>>
<<Implement>><<Implement>>
<<Implement>><<Implement>>
begin ()destroy ()nuevo ()end ()guardar ()getIdFacultad ()setIdFacultad (int idFacultad)getIdCarrera ()setIdCarrera (int idCarrera)getIdEscuela ()setIdEscuela (int idEscuela)getListaFacultades ()setListaFacultades (List<SelectItemObj> listaFacultades)getListaEscuelas ()setListaEscuelas (List<SelectItemObj> listaEscuelas)getListaCarreras ()setListaCarreras (List<SelectItemObj> listaCarreras)getDocumento ()setDocumento (String documento)getAbreviaturaDoc ()setAbreviaturaDoc (String abreviaturaDoc)getSecuencialActual ()setSecuencialActual (int secuencialActual)getListaTabla ()setListaTabla (List<Object[]> l istaTabla)getDepartamento ()setDepartamento (String departamento)...
: void: void: void: void: void: int: void: int: void: int: void: List<SelectItemObj>: void
: List<SelectItemObj>: void
: List<SelectItemObj>: void
: String: void: String: void
: int: void
: List<Object[]>: void
: String: void <<EJBLocal>>
admFuncionesRol
+++++++++
++++
++++++
end ()guardarFuncionRol ()nuevo ()begin ()destroy ()buscarFuncionRol ()cambiarEstado (Object obj[])getListaTabla ()setListaTabla (List<Object[]> l istaTabla)getIdRol ()setIdRol (int idRol)getListaRoles ()setListaRoles (List<SelectItemObj> listaRoles)getIdFuncion ()setIdFuncion (String idFuncion)getPermisos ()setPermisos (Permisos permisos)getListaFunciones ()setListaFunciones (List<SelectItemObj> listaFunciones)...
: void: void: void: void: void: void: void: List<Object[]>: void
: int: void: List<SelectItemObj>: void
: String: void: Permisos: void: List<SelectItemObj>: void
<<EJBSession>>admFuncionesRolBean
-*******------
logfacesMessagesidentitycredentialsautSrvpermisoSrvrolesSrvfuncionSrvidFuncionidRolpermisoslistaRoleslistaFuncioneslistaTabla
: Log: FacesMessages: Identity: Credentials: AutenticadorServicio: PermisosServicio: RolesServicio: FuncionesServicio: String: int: Permisos: List<SelectItemObj>: List<SelectItemObj>: List<Object[]>
+++++++++
++++
++++++
<<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>>
<<Implement>><<Implement>><<Implement>><<Implement>>
<<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>>
begin ()destroy ()nuevo ()end ()guardarFuncionRol ()buscarFuncionRol ()cambiarEstado (Object obj[])getListaTabla ()setListaTabla (List<Object[]> l istaTabla)getIdRol ()setIdRol (int idRol)getListaRoles ()setListaRoles (List<SelectItemObj> listaRoles)getIdFuncion ()setIdFuncion (String idFuncion)getPermisos ()setPermisos (Permisos permisos)getListaFunciones ()setListaFunciones (List<SelectItemObj> listaFunciones)...
: void: void: void: void: void: void: void: List<Object[]>: void
: int: void: List<SelectItemObj>: void
: String: void: Permisos: void: List<SelectItemObj>: void
Figura 26. Diagrama de Clases (2)Autor: Mario Castellanos
Fuente: Tesista
43
<<EJBLocal>>Autenticador
++++++
authenticate ()destroy ()showGlobalMessages ()updateLogin ()getAcceso ()setAcceso (Acceso acceso)...
: boolean: void: boolean: void: Acceso: void
<<EJBSession>>AuthenticatorBean
-*******---
logfacesMessagesidentityadmEmpresacredentialsautSrvwebServicessrvAutusuarioLoginclaveLoginacceso
: Log: FacesMessages: Identity: AdmEmpresa: Credentials: AutenticadorServicio: WebServices: ServicioAutenticacion: String: String: Acceso
++++++
<<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>>
authenticate ()updateLogin ()destroy ()showGlobalMessages ()getAcceso ()setAcceso (Acceso acceso)...
: boolean: void: void: boolean: Acceso: void
<<EJBLocal>>admUsuarioRol
+++++++++
++++++++
++
end ()guardarUsuarioRol ()nuevo ()begin ()destroy ()buscarUsuarioRol ()cambiarEstado (Object obj[])getListaTabla ()setListaTabla (List<Object[]> l istaTabla)getIdUser ()setIdUser (String idUser)getIdRol ()setIdRol (int idRol)getAccesoRol ()setAccesoRol (AccesoRol accesoRol)getListaRoles ()setListaRoles (List<SelectItemObj> listaRoles)getListaUsuarios ()setListaUsuarios (List<SelectItemObj> listaUsuarios)...
: void: void: void: void: void: void: void: List<Object[]>: void
: String: void: int: void: AccesoRol: void: List<SelectItemObj>: void
: List<SelectItemObj>: void
<<EJBSession>>admUsuarioRolBean
-*******------
logfacesMessagesidentitycredentialsautSrvaccesRolSrvrolesSrvempSrvidUseridRolaccesoRollistaRoleslistaUsuarioslistaTabla
: Log: FacesMessages: Identity: Credentials: AutenticadorServicio: AccesoRolServicio: RolesServicio: EmpleadosServicio: String: int: AccesoRol: List<SelectItemObj>: List<SelectItemObj>: List<Object[]>
+++++++++
++++++++
++
<<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>>
<<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>><<Implement>>
<<Implement>><<Implement>>
begin ()destroy ()nuevo ()end ()guardarUsuarioRol ()buscarUsuarioRol ()cambiarEstado (Object obj[])getListaTabla ()setListaTabla (List<Object[]> l istaTabla)getIdUser ()setIdUser (String idUser)getIdRol ()setIdRol (int idRol)getAccesoRol ()setAccesoRol (AccesoRol accesoRol)getListaRoles ()setListaRoles (List<SelectItemObj> listaRoles)getListaUsuarios ()setListaUsuarios (List<SelectItemObj> listaUsuarios)...
: void: void: void: void: void: void: void: List<Object[]>: void
: String: void: int: void: AccesoRol: void: List<SelectItemObj>: void
: List<SelectItemObj>: void
Figura 27. Diagrama de Clases (3)Autor: Mario Castellanos
Fuente: Tesista
44
3.3. FASE DE CONSTRUCCION
3.3.1.Modelo de Implementación
*Diagrama de Componentes
Figura 28. Diagrama de ComponentesAutor: Mario Castellanos
Fuente: Tesista
Ingreso_al_sistema
Registro_Empleados
Registro_Estudiante
Registro_Profesores
Registro de Roles
Registro_Usuarios Registro_Plan_Tesis
Asignacion_Tutor
Asignacion_Revisores
Registro_de_Tutorias
Defensa_Grado
45
3.3.2.Flujo del Proceso de Gestión de Tesis
Bajo el análisis anteriormente presentado, ya es posible estructura el proceso. A fin
de generalizar, resulta factible utilizar tareas multi-instancia en las actividades de
revisión y tribunal calificador; además implica hacer uso de varios subprocesos.
En vista de lo citado, se define:
El proceso Registrar Estudiante, con el subproceso Registro Estudiante.
El Proceso Calificación Tesis, con el subproceso Calificar Documento.
El proceso Revisión solicitud Defensa Oral, con el subproceso Revisión Oficio
Defensa Oral.
Subproceso “Registro Estudiante”
En este proceso es donde se realiza el registro del estudiante y del usuario, a partir de
los datos ingresados por la Secretaria (Iniciador), y finalmente se notifica al
estudiante que ha sido registrado y que se ha creado su usuario para acceder al
sistema de gestión.
Figura 29. Subproceso Registro EstudianteAutor: Mario CastellanosFuente: Tesista
Subproceso “Calificar Documento”
En estos procesos intervienen los siguientes actores: Docentes del tribunal calificador
del documento y el estudiante; previamente de la calificación del documento de tesis,
el tutor debe emitir un informe de aprobación y el estudiante debe solicitar un
tribunal Calificador del Documento de Tesis.
En este proceso los docentes que conforman el tribunal calificador del documento de
tesis, visualizan el oficio de que han sido designados como miembros del tribunal,
deben revisar el documento de tesis en el caso de existir observaciones el estudiante
debe realizar las debidas correcciones, en el caso de que se encuentre el documento
correcto los miembros del tribunal deben ingresar la calificación del mismo.
46
Figura 30. Subproceso Calificar DocumentoAutor: Mario CastellanosFuente: Tesista
Subproceso “Revisión Oficio Defensa Oral”
Después de que el tribunal calificador del documento de tesis entregue la nota final,
el estudiante solicita que se le asigne un tribunal para la defensa oral de grado;
conformándolo el Subdecano de la Carrera, El tutor de Tesis, Los miembros del
tribunal de la defensa oral podrán visualizar el oficio de asignación.
Figura 31. Subproceso Revisión Oficio defensa OralAutor: Mario CastellanosFuente: Tesista
3.4. FASE DE TRANSICION
3.4.1.Manual de Instalación
Este documento incluye los pasos para la instalación del producto software. Debido a
la extensión de este documento referirse a los Anexos.
3.4.2.Manual de Usuario
Este documento explica el correcto manejo del sistema. Debido a la extensión de este
documento referirse a los Anexos.
47
3.5. FASE DE PRUEBAS
3.5.1. Recursos requeridos
Hardware Base del Sistema
La siguiente tabla muestra los recursos del sistema para realizar el Plan de Pruebas.
Recurso Cantidad Tipo
Servidor
- Disco
- Memoria
- Procesador
1
Mínimo 30GB
Mínimo 4GB
Mínimo Pentium 4
PC-Clientes
- Requerimientos
especiales de
configuración
0-n Internet Explorer 8 o
superior
Tabla 12. Requisitos Hardware PruebasAutor: Mario Castellanos
Fuente: Tesista
Software Base del Sistema
La siguiente tabla muestra los recursos mínimos del sistema para realizar el Plan de
Pruebas.
Elemento Software Tipo
Windows XP o superior Sistema Operativo
Internet Explorer 8 o
superior
Navegador Web
Jboss 5.1 Servidor de Aplicaciones
48
Elemento Software Tipo
Postgres 9.3 Servidor de Base de datos
Tabla 13. Requisitos Software PruebasAutor: Mario Castellanos
Fuente: Tesista
3.5.2. Plan de Pruebas
El plan de pruebas del Sistema de Gestión de las Tesis de Grado de la Facultad de
Jurisprudencia de la Universidad Central, tiene como objetivos:
Identificar las pruebas que se realizarán en el sistema.
Identificar problemas en el funcionamiento del sistema.
Este Plan de Pruebas está dirigido exclusivamente para la o las personas encargadas
de la verificación funcional del sistema o para aquellas personas que vean en este
documento una ayuda al uso impropio del sistema.
La siguiente tabla que se presenta a continuación, permitirá determinar para cada
requisito la característica a ser probada su funcionalidad.
Requisito Característica a probar
Administración de Facultades
- Crear Facultad
- Buscar Facultad
- Editar Facultad
- Exportar a Excel
Administración de Escuelas
- Crear Escuelas
- Buscar Escuelas
- Editar Escuelas
49
Requisito Característica a probar
- Exportar a Excel
Administración de Carreras
- Crear Carrera
- Buscar Carrera
- Editar Carrera
- Exportar a Excel
Administración de Empleados
- Creación del Empleado
- Búsqueda del Empleado mediante la
cédula.
- Editar un Empleado
- Exportar a Excel los empleados.
- Carga masiva de los empleados a
través de un archivo Excel.
Administración de Profesores
- Creación del Profesor
- Búsqueda del Profesor mediante la
cédula.
- Edición un profesor
- Exportar a Excel los profesores.
- Carga masiva de los profesores a
través de un archivo Excel.
Flujo en Bonita - Flujo Completo Gestión Tesis
Tabla 14. Plan Pruebas Gestión UsuarioAutor: Mario Castellanos
Fuente: Tesista
3.5.3. Pruebas de Carga
Performance
Muestra los valores de tiempo de respuesta promedio a través de todos los perfiles
de usuario, para nuestro caso se puede observar el mayor tiempo promedio de
respuesta es de 0.1 segundos se considera dentro del rango aceptado.
50
Gráfico de tiempo de respuesta le dirá cuánto tiempo un usuario espera la respuesta
del servidor a su petición.
Muestra el número de páginas ejecutadas por unidad de escala de tiempo
(segundos), para nuestro caso se presenta un 1.83 páginas por segundo.
Figura 32. Prueba de Carga - Performance DataAutor: Mario Castellanos
Fuente: Tesista
Tenga en cuenta que puede usar esa interpretación del gráfico de tiempo de
respuesta sólo si el gráfico de tiempo de descarga no exhibe un crecimiento
esencial. Si el porcentaje de tiempo de descarga de tiempo de respuesta es
más bien alto, indica que hay problemas con el ancho de banda de conexión,
pero no con el rendimiento del servidor
Bandwidth
Nos ayudara a saber si el ancho de banda de conexión a Internet para su servidor es
suficiente para proporcionar un nivel aceptable de rendimiento o no.
51
Muestra la cantidad que se enviaron los kbits por segundo al servidor, dando como
resultado 19.1 kbits por cada segundo
Figura 33. Prueba de Carga –BandwidthAutor: Mario Castellanos
Fuente: Tesista
ErrorEstos gráficos le ayudarán a saber cómo cambia la tasa de error durante una pruebacuando el número de usuarios virtuales es cada vez mayor.Se puede observar que el porcentaje de respuestas con errores HTTP desde elnúmero total de respuestas es de 66.7% como máximo y un mínimo de 9.09%El porcentaje de respuestas con errores de la red a partir del número total derespuestas es de 0%.
52
Figura 34. Prueba de Carga – ErrorAutor: Mario Castellanos
Fuente: Tesista
Para realización de las pruebas de carga se utilizó la herramienta: WAPT versión
gratuita; y las pruebas se hizo en base al plan de pruebas.
3.5.4. Pruebas de Stress
"Las pruebas de estrés aumentan la probabilidad de encontrar un error crítico de
concurrencia o un problema de la memoria".
Para lo cual se ha realizado las respectivas pruebas de stress de acuerdo al plan de
pruebas antes mencionado, dando como resultado lo siguiente:
53
Performance
Para la prueba de estrés, se muestra la figura en la que se puede apreciar que el
tiempo de respuesta promedio a través de todos los perfiles de usuario, para nuestro
caso se puede observar el mayor tiempo promedio de respuesta es de 0.69 segundos
se considera dentro del rango aceptado.
En el gráfico el tiempo de procesamiento promedio es de 0.35 segundos.
El promedio del tiempo descarga es menor que el tiempo de respuesta promedio,
esto nos indica que no hay problemas con el ancho de banda de conexión, y ademas
afecta con el rendimiento del servidor
Figura 35. Prueba de Estrés – PerformanceAutor: Mario Castellanos
Fuente: Tesista
Bandwidth
Muestra la cantidad que se enviaron los kbits por segundo al servidor, dando como
resultado 16.9 kbits por cada segundo y la cantidad recibido es de 545 kbits por cada
segundo, es decir que se el servidor esta respondiendo corretamente a todas las
peticiones de una manera correcta.
54
Figura 36. Prueba de Estrés – BandwidthAutor: Mario Castellanos
Fuente: Tesista
Error
En la gráfica se puede observar que el porcentaje de respuestas con errores de la red
a partir del número total de respuestas es de 0%.
El porcentaje del respuesta con errores HTTP a partir del número total de respuesta
es 66.7% como máximo.
55
Figura 37. Prueba de Estrés – ErrorAutor: Mario CastellanosFuente: Tesista
Tasa de error es el resultado más valioso de las pruebas de estrés, donde
tienes que encontrar el número máximo de usuarios que pueden ser servidos
correctamente, sin errores. Usted también tendrá que ver la tasa de errores
durante las pruebas de fiabilidad / resistencia para comprobar que está dentro
del rango aceptable, incluso después de una larga carrera.
56
4. CAPITULO IV.
4.1. Conclusiones
En el presente proyecto ha sido un trabajo, ha recogido las siguientes conclusiones:
BPM (Business Process Management) es una metodología la cual nos permite
mejorar de manera continua, incrementando la efectividad de los procesos dentro
de la Facultad de Jurisprudencia de la Universidad Central del Ecuador.
Un sistema Gestor de Tesis requiere apoyarse en sistemas de Gestión
Documental, debido al uso elevado de documentos digitales que son
necesariamente administrados; y además de un sistema de Gestión de Reglas de
Negocio, que permitan concentrar reglas que cambian continuamente, en un solo
repositorio centralizado. De esta forma, se integra un Sistema BPM.
El sistema de Gestión de Tesis, redundara en beneficio a los empleados y
estudiantes de la Facultad de Jurisprudencia de la Universidad Central, ya que
permitirá automatizar los procesos, contribuyendo a la mejora de la calidad de
servicio. Todo proceso podrá ser agilizado y los beneficiados podrán estar al
tanto de su estado en cualquier momento, gracias a la tecnología Web empleada.
Con el Sistema de automatización de Gestión de las Tesis de Grado
proporcionado a la Facultad de Jurisprudencia, se pretende agilitar y facilitar
automatizar éste proceso; logrando así disminuir el tiempo que conlleva realizar
éstas tareas de manera manual y a la vez que cada uno de los actores implicados
sepan en que parte del proceso se encuentra cada Proyecto de Tesis.
En la actualidad se propone como solución a flujos de procesos, el uso de
herramientas BPM, las cuales deben ser elegidas de manera correcta
dependiendo de la complejidad del flujo y de los recursos disponibles.
57
4.2. Recomendaciones
Para obtener un funcionamiento apropiado del Sistema de Gestión de Tesis, se
recomienda que el servidor donde se alojara la aplicación debería tener como
mínimo memoria de 4 GB y además que el servidor sea solo para aplicación.
El presente sistema podría ser mejorado, en lo que se refiere a las tutorías que
tiene el tutor, implementando un seguimiento y calendarización de las fechas de
tutoría, notificación automática al correo o celular de que el tutor tiene una
reunión con el tesista.
Se recomienda usar la versión BPM Subscription Pack, debido a que la versión
Community esta limita en cuanto al uso de eventos dentro de las pantallas de
navegación.
De acuerdo a lo consultado con las autoridades de la Facultad, se conserva los
Oficios, Solicitudes e Informes de manera física a modo de respaldo. Se
recomendaría en un futuro el uso firmas digitales con las debida s normas de
seguridad, para que logre una conciencia de “cero papeles”.
Se recomienda que en un futuro el sistema de Gestión de Tesis se integre con el
sistema SAU para así obtener directamente la información de los estudiantes sin
la necesidad de registrarlo.
Se recomienda desarrollar una interfaz gráfica la cuál permita interactuar con el
gestor documental de alfresco, permitiendo realizar búsquedas de los
documentos mediante filtros (Cédula , Nombre Documento, etc.)
58
BIBLIOGRAFÍA
1. BPM BUSINESS PROCESS MANAGEMENT, Obtenido desde:
http://www.ibermatica.com/ibermatica/bpm
2. JAVA EE, Plataforma de programación. Obtenido desde:
http://es.wikipedia.org/wiki/Java_EE
3. JBOSS, Servidor de aplicaciones. Obtenido desde:
http://es.wikipedikia.org/wiki/JBoss
4. DISEÑADOR GRÁFICO DE PROCESO JBOSS JBPM. Obtenido el 01 de
mayo de 2013 desde http://docs.jboss.org/jbpm/v3/spanish/jbpm-gpd-
installation-spanish.pdf
5. INTALIO BPMN. Obtenido el 01 de mayo de 2013 desde http://www.sidesoft-
ecuador.com/productos-y-servicios/sideconsulting/intaliobpm.html
6. PROCESSMAKER, WORKFLOWSIMPLIFIED. Obtenido el 01 de mayo de
2013 desde http://wwwhatsnew.com/2008/07/21/processmaker-bpm-orientado-
a-todo-tipo-de-diseno-y-flujo-de-procesos/.
7. BONITA, Obtenido el 01 de mayo de 2013 desde http://es.bonitasoft.com/
8. BONITA OPEN SOLUTION, tomado de
http://es.slideshare.net/frousseaux/todo-acerca-de-bonitasoft-openbpm.
9. COMPARATIVA ENTRE ECM Obtenido el 01 de mayo del 2013 desde
http://blog.athento.com/2009/02/alfresco-vs-nuxeo-gestion-documental.html
10. ALFRESCO. Obtenido el 01 de mayo del 2013 desde
http://www.cyberpymes.com/aplicaciones-a-medida/alfresco/alfresco-
caracteristicas.html
11. NUXEO. Obtenido el 01 de mayo del 2013 desde
http://www.athento.com/nuxeo/caracteristicas/
12. ALFRESCO, tomado de http://www.cyberpymes.com/aplicaciones-a-
medida/alfresco-caracteristicas
59
13. METODOLOGÍA DESARROLLO. Obtenido desde
http://es.scribd.com/doc/12983329/Metodologia-de-Desarrollo-de-Software
14. METODOLOGÍA XP, Obtenido el 12 de julio del 2014 desde
http://es.slideshare.net/Piskamen/metodologa-xp.
15. METODOLOGÍA RUP, Obtenido el 12 de julio del 2014 desde
http://es.slideshare.net/cortesalvarez/metodologa-rup.
16. METODOLOGÍA MSF, Obtenida el 12 de julio del 2014 desde
http://es.slideshare.net/bebeyom/metodologia-msf-4861508.
17. UML Lenguaje Unificado de Modelado, obtenido el 12 de julio del 2014 desde
http://www.omg.org/spec/UML/2.1.2/Superstructure/PDF
60
5. ANEXOS
1
Anexo
A
REQUERIMIENTOS
2
Recopilación de requerimientos
Requerimientos Funcionales:
Impresión del comprobante de entrega del plan.
Permite subir el Plan de Tesis.
Permite la designación del investigador y revisores del Plan de Tesis
automáticamente.
Permite la designación automática del tutor.
Permite el registro de las tutorías.
Permite designación del tribunal calificador de la tesis.
Registro de las notas: el escrito, el oral.
Impresión del título de grado.
Requerimientos No Funcionales:
Escalabilidad
El sistema debe ser construido sobre la base de un desarrollo rápido de aplicaciones
de manera tal, que nuevas funcionalidades puedan ser incrementadas provenientes de
servicios web, afectando el código existente de la menor manera posible.
El diseño debe contemplar el un adecuado uso de recursos como conexiones a la base
de datos, conexiones desde el servidor.
Disponibilidad
Estar disponible 100% o muy cercano a esta disponibilidad durante las 24x7x365.
Debe contemplar requerimientos de confiabilidad y consistencia de los componentes
de negocio ante recuperaciones. En caso de fallas de algún componente, no debe
haber pérdida de información.
Seguridad
3
La seguridad del sistema debe estar regida a base de roles que serán asignados a cada
uno de los usuarios.
El acceso al Sistema debe estar restringido por el uso de claves asignadas a cada uno
de las personas involucradas en el sistema.
Sólo podrán ingresar al Sistema las personas que estén registradas, estos usuarios
serán clasificados en varios tipos de usuarios (o roles) con acceso a las opciones de
trabajo definidas para cada rol.
Respecto a la confidencialidad, el sistema debe estar en capacidad de rechazar
accesos o modificaciones indebidos (no autorizados) a la información y proveer los
servicios requeridos por los usuarios legítimos del sistema.
Mantenibilidad
Toda el sistema deberá estar completamente documentado, cada uno de los
componentes de software que forman parte de la solución propuesta deberán estar
debidamente documentados tanto en el código fuente como en los manuales.
Facilidad de Uso
El sistema debe ser de fácil uso, así como de fácil adaptación para las personas que
hagan uso del sistema.
El sistema no debe permitir el cierre de una operación hasta que todos sus procesos,
subprocesos y tareas relacionados, hayan sido terminados y cerrados
satisfactoriamente.
El sistema debe presentar mensajes de error que permitan al usuario identificar el
tipo de error y comunicarse con el administrador del sistema.
1
Anexo
B
MANUAL DE INSTALACIÓNDEL SOTWARE
2
Tabla de contenido
1. SISTEMA OPERATIVO (CentOS 6.4) ........................................................... 3
2. JAVA JDK......................................................................................................... 12
3. BASE DE DATOS............................................................................................ 14
4. SERVIDOR DE APLICACIONES (JBOSS) ................................................ 16
Iniciar Jboss ............................................................................................................ 16
5. GESTOR DE REGLAS DE NEGOCIO (Drools) ........................................ 17
6. GESTOR BPM (BONITA) .............................................................................. 18
7. GESTOR DOCUMENTAL (ALFRESCO) .................................................... 21
Alfresco como servicio........................................................................................... 25
8. LIBRERÍAS DE LA PLATAFORMA............................................................. 27
9. ARRANQUE DE LA APLICACIÓN .............................................................. 27
3
1. SISTEMA OPERATIVO (CentOS 6.4)
El instalador se encuentra disponible en el DVD centOS 6.4.
La instalación se la realizara de la siguiente manera:
1. Se debe arrancar al computador desde el DVD CentOS 6.4. Una vez
presentada la pantalla de arranque, se procede a dar Enter.
2. El paso siguiente es elegir la opción Skip para evitar una verificación
innecesaria de datos del DVD.
Figura 38. Skip de verificación
3. Se debe elegir el idioma con el cual se procederá la instalación
Figura 39. Elección Idioma instalación
4. A continuación se procede a elegir el idioma del teclado.
4
Figura 40. Elección Idioma del teclado
5. El siguiente paso es confirmar si se desea conservar los datos del dispositivo
de almacenamiento, para lo cual damos clic en Si, descarte todos los datos.
Figura 41. Conservar datos del dispositivo
6. A continuación se debe establecer un nombre de host, que permitirá
identificar al computador dentro de una red.
5
Figura 42. Establecer nombre del Host
7. En la siguiente pantalla se debe seleccionar el huso horario en el que se
encuentra, en nuestro caso elegimos América/Guayaquil.
Figura 43. Establecer huso horario
8. A continuación se debe establecer una contraseña para el usuario root, que es
el encargado de la administración del sistema operativo, en nuestro caso la
contraseña será ucentral2015.
6
Figura 44. Establecer contraseña del Root
9. En el siguiente paso se debe configurar las particiones para el sistema
operativo.
Para poder realizarlo, es necesario elegir la opción Crear un diseño
personalizado.
Figura 45. Elección del tipo de particiones
10. La siguiente pantalla permitirá configurar las particiones.
7
Figura 46. Configuración de particiones
Para crear una nueva partición, se debe hacer clic sobre el botón Crear, seleccionar
Partición Estándar y clic en Crear.
Figura 47. Crear Partición
Es necesario tener libre una partición lógica para este proceso.
Como primer paso se debe crear una partición SWAP, eligiendo como tipo de
sistema de archivos la mencionada partición.
El tamaño de la particion SWAP es quivalente al tamaño de la memoria virtual,
por lo que se debe asignar su tamaño de acuerdo a las siguietes reglas:
-Si el ordenador tiene menos de 1 GB, se debe asignar el mismo tamaño.
-Si el ordenador tiene entre 2GB y 4GB, se asigna la mitad de la RAM.
8
-Si el ordenador tiene mas de 4GB en RAM, se establece un tamaño de 2GB.
Y finalmente se crea la partición en la que se cargara el sistema operativo. Para lo
que es necesario establecer el tipo de sistema de archivos ext3 con punto de montaje
/, seleccionando la opcion Completar hasta el tamaño maximo permitido.
La configuración se mostrara una disposición peresonalizada similar a la siguiente:
Figura 48. Disposición personalizada de particiones
11. Posteriormente se presenta el mensaje de formateo de la partición, dar clic en
Formato.
9
12. Posteriormente se configura el gestor de arranque.
Figura 49. Establecer Gestor de Arranque
13. En la siguiente pantalla permitirá personalizar los paquetes a instalar, para
ello elegir la opción Personalizar ahora y seleccionar Desktop.
Figura 50. Elección de entorno previo a personalización de paquetes
14. A continuación se debe elegir los paquetes necesarios que se incluirán en la
instalación.
Las categorías que contienen los paquetes necesarios son los siguientes:
Desarrollo
Desarrollo adicional
Herramientas de desarrollo
Servidores
Servidor FTP
10
Servidor de archivo DNS
Servidor de correo-e
Sistema Base
Bibliotecas de compatibilidad
No se debe instalar el servidor de base de datos PostgresSQL, ya que será
instalado posteriormente.
15. El sistema operativo está listo para ser instalado, esto tomara alrededor de 30
minutos.
Figura 51. Inicia la instalación
16. Es necesario realizar cabios posteriores a la instalación, tales deshabilitar
Kdump y establecer un usuario (no administrativo). Se opta por usar el
usuario gestiontesis con contraseña gestiontesis.
11
Figura 52. Establecer usuario (No administrativo)
Finalmente se debe reiniciar y la instalación habrá concluido.
12
2. JAVA JDK
Para instalar el JDK en el sistema operativo CentOS se procede de la siguiente
forma:
1. Se debe copiar el archivo del CD:/instaladores-basicos/jdk-6u45-linux-
i586.bin en la ubicación /opt y elegir la opción Ejecutar en un terminal.
Figura 53. Url en la terminal
En el caso de no ejecutarse, se debe acceder a las propiedades del archivo
y verificar si la opción Permitir ejecutar el archivo como un programa
este habilitado.
2. A continuación se mostrara la licencia de Java. Presionar la tecla Enter hasta
que se presente el mensaje Do you agree to the above license terms? [yes or
no] y digitamos yes y presionamos Enter. En caso de ser requerido.
Figura 54. Aceptación de la licencia Java
13
3. Una vez terminada la instalación se debe establecer la variable de entorno
JAVA_HOME, para ello se debe modificar el archivo profile ubicado en /etc/,
añadiendo las siguiente líneas al final.
export JAVA_HOME=/opt/ jdk1.6.0_45
export PATH=$PATH:$JAVA_HOME/bin
4. Cambiar la versión de Java del sistema operativo que viene por defecto a la
nueva que fue instalada. Para lo cual se emplea los siguientes comandos.
alternatives --install /usr/bin/java java /opt/jdk1.6.0_45/bin/java 100
alternatives --install /usr/bin/javac javac /opt/jdk1.6.0_45/bin/javac 100
alternatives --install /usr/bin/jar jar /opt/jdk1.6.0_45/bin/jar 100
alternatives --config java
En la siguiente pantalla, se debe elegir la versión instalada a través de su
número de selección (3) y dar Enter.
Figura 55. Cambio de versión Java
5. Se debe verificar la versión de java con el comando: java -version
Figura 56. Versión de Java
14
3. BASE DE DATOS
La instalación del servidor de base de datos PostgreSQL debemos seguir los
siguientes pasos:
1. Debemos copiar el archivo del CD:/instaladores-basicos/postgresql-9.3.2-1-linux.run a la ubicación /opt y ejecutamos dando doble clic, lo cual iniciara elasistente de instalación. Y damos clic en siguiente.
Figura 57. Ejecutar el instalador.
2. A continuación nos toca definir el directorio de instalación/opt/PostgreSQL/9.3 y el directorio de datos en /opt/PostgreSQL/9.3/data.
Figura 58. Definición del directorio instalación
15
3. Lo siguiente es definir una contraseña para el súper - usuario (postgres). Lacontraseña establecida es root.
Figura 59. Definición de contraseña
4. La pantalla siguiente, permite definir el puerto de escucha para el servidorPostgreSQL. Mantener el valor por emisión en 5432.
Figura 60. Puerto de PostgreSQL
5. A continuación tenemos las opciones avanzadas. Aquí se elige laconfiguración regional.
Figura 61. Opciones Avanzadas de PostgreSQL
6. Por último, el asistente procede a instalar PostgreSQL y sus componentes. Al
finalizar, el asistente permite la opción Stack Builder para instalar más
16
componentes de PostgreSQL. No requerimos extender PostgreSQL para este
proyecto, por lo tanto desactivamos la opción y terminar.
4. SERVIDOR DE APLICACIONES (JBOSS)En el siguiente apartado vamos a instalar el servidor de aplicaciones, para que corran
las aplicaciones.
Para este procedimiento haremos uso del archivo del jboss-5.1.0.GA.zip y realizamos
el siguiente paso:
1. Descomprimimos el contenido del fichero del CD: /instaladores-
basicos/jboss-5.1.0.GA.zip en la ubicación /opt/GESTION_TESIS/ (En caso
de no existir la carpeta debe crearla).
2. Para evitar conflictos entre el servidor de aplicaciones y el gestor documental
de alfresco debemos cambiar de puerto el servidor de aplicaciones del 8080 al
8081. Para este fin realizaremos el siguiente procedimiento:
Modificamos el puerto del archivo bindings-jboss-beans ubicado en
opt/jboss-5.1.0.GA/server/default/conf/bindingservice.beans/META-
INF, o copiamos el archivo de la ubicación
CD:/configuraciones/ficheros-configuracion/configuracionesjboss y lo
reemplazamos; de tal forma que quede de la siguiente manera:
Iniciar Jboss
1. Abrir una terminal
2. Debemos direccionar en la carpeta del Servidor Jboss, para lo cual
ejecutamos en la terminal lo siguiente:
cd /opt/GESTION_TESIS/JBoss-5.1.0.GA/bin
3. Para poder arrancar el Jboss se debe primero conceder permisos para lo cual
ejecutamos en la terminal los siguiente:
chmod 777 run-sh
4. Ejecutar a continuación lo siguiente:
./run.sh
Esperar unos minutos hasta que el servidor termine de subirse y aparezca
al final lo siguiente:
17
Para verificar su funcionamiento digitamos en el navegador
http://localhost:8180/
Figura 62. Pantalla del servidor de aplicaciones
5. GESTOR DE REGLAS DE NEGOCIO (Drools)
En este apartado se presenta los pasos de instalación del Gestor de Reglas de
Negocio (BRMS).
Para dicho procedimiento hacemos uso del archivo CD:/instaladores-basicos/drools-
guvnor.war, el mismo que será pegado en el servidor de aplicaciones visto
anteriormente en la ubicación /opt/GESTION_TESIS/JBoss-5.1.0.GA
/server/default/deploy.
P
ara verificar su funcionamiento digitamos en el navegador
http://localhost:8180/drools-guvnor.
E
n el caso de que el servidor de Jboss este en ejecución se debe reiniciar
el servidor(Detener E iniciar el Servidor)
18
Figura 63. Pantalla inicial del Gestor de Reglas Drools
6. GESTOR BPM (BONITA)En esta sección se detallara la instalación del Gestor Bonita. Para lo que haremos uso
de las librerías del CD:/configuraciones/librerías/libreriasBonita.
Para instalar el gestor bonita realizamos los siguientes pasos:
1. Copiamos los archivos de CD:/configuraciones/librerías/libreriasBonita en la
ubicación /opt/GESTION_TESIS/JBoss-5.1.0.GA/server/default/deploy.
(Reemplazar si es necesario)
2. Damos subimos el servidor de aplicaciones Jboss, para lo cual realizamos los
paso de Iniciar Jboss.
Los pasos para la instalación es el siguiente:
1. Extraer el contenido del fichero del CD: /instaladores-base/ BOS-5.9.1-lin-
setup.zip en la dirección /opt/GESTION_TESIS.
2. Ejecutar en la terminal los siguiente:
/opt/GESTION_TESIS/BOS-5.9.1-lin-setup/BOS-5.9.1-setup
3. A continuación seleccionar el idioma de la instalación (Spanish-Español):
19
4. A continuación seleccionar el JVM(1.6.0_45):
5. Luego se presenta la pantalla de Inicio de la Instalación:
6. Paso siguiente Aceptamos las condiciones
20
7. A continuación establecer el destino del directorio de instalación.
(/opt/GESTION_TESIS/BOS-5.9.1)
8. Paso siguiente comienza la instalación.
21
9. A continuación No importar ningún workspace y luego clic en Finalizar
7. GESTOR DOCUMENTAL (ALFRESCO)En esta sección se detallara la instalación del Gestor Documental Alfresco. Para lo
que haremos uso del archivo del CD:/instaladores-basicos/alfresco-community-3.4.d-
installer-linux-x32.bin.
Los pasos para la instalación es el siguiente:
1. Debemos copiar el archivo a la ubicación /opt/GESTION_TESIS/.
2. Ejecutamos el archivo copiado en la terminal ingresando en la terminal la url
del archivo, y elegimos el idioma de instalación.
Figura 64. Elección del idioma de instalación
3. En la siguiente pantalla elegiremos los componentes que serán instalados,para nuestro caso marcamos todos (Excepto MySQL y JAVA).
22
Figura 65. Selección de los componentes a instalar
4. A continuación elegimos el tipo de instalación avanzada, y también la carpetaen la que se va a instalar, se debe cambiar la que ubicación que esta pordefecto a la ubicación /opt/GESTION_TESIS/alfresco.
Figura 66. Elección de la carpeta de instalación
Para instalar el gestor previamente debe estar creada la base de datosalfresco.
5. Paso siguiente es elegir la opción Quiero utilizar una base de datos existente,
y establecer la configuración de la base de datos, tales como el url de JDBC
(jdbc:postgresql://localhost:5432/alfresco), controlador de JDBC
23
(org.postgresql.Driver), nombre de la base de datos (alfresco), nombre de
usuario(postgres) y contraseña(root).
Figura 67. Configuración de la base de datos
Nota: la base de datos alfresco debe ser creada con anterioridad.
6. A continuación ingresar los parámetros de configuración de tomcat, para
nuestro caso mantenemos los valor por defecto, debe quedar así:
Figura 68. Configuración de tomcat
7. Establecer el puerto FTP de alfresco (Por emisión 21)
24
Figura 69. Puerto FTP de alfresco
8. Establecer el puerto RMI de alfresco (Por Emisión 50500)
Figura 70. Puerto RMI de Alfresco
9. A continuación definimos la contraseña admin para la cuenta de
administrador de alfresco (Admin).
25
Figura 71. Establecer contraseña de alfresco
10. Posteriormente tenemos que definir los puertos para el SharePoint y Quickr,
para nuestro caso los dejaremos con los valores por defecto.
11. Paso siguiente no definirlo como servicio del sistema.
Figura 72. Instalar como servicio a alfresco
12. A continuación el asistente procede a instalar alfresco. Una vez finalizadodamos clic en terminar.
Alfresco como servicio
Modificar el fichero /opt/GESTION_TESIS/alfresco/alfresco.sh para que pueda ser
añadido como servicio, agregando las líneas siguientes al encabezado (Después de la
primera línea #!/bin/sh).
# chkconfig: 345 91 10
26
# description: Start or Stop Alfresco Server
Crear un link simbólico sobre el script alfresco.sh, que provee la instalación de
Alfresco en la dirección /opt/GESTION_TESIS/alfresco, mediante los siguientes
comandos ejecutados sobre un terminal:
cd /etc/init.d
ln -s /opt/GESTION_TESIS/alfresco/alfresco.sh alfresco
chkconfig --add alfresco
Una vez configurado el servicio, se puede arrancar o parar el mismo, haciendo uso de
los siguientes comandos de forma respectiva:
service alfresco start
service alfresco stop
Para poder acceder a la pantalla inicial de alfresco, digitamos en el
navegador http://localhost:8080/alfresco.
27
Figura 73. Pantalla inicial de alfresco
8. LIBRERÍAS DE LA PLATAFORMA
Copiar los archivos .jar de las diferentes carpetas que se encuentran en el CD:
INSTALADORES/configuraciones/librerias/ y pegarlos (reemplazar si es requerido)
en las siguentes direcciones:
De la carpeta libreriasBPM en la dirección /opt/GESTION_TESIS/Jboss-
5.1.0.GA/server/default/lib.(Reemplazar si es necesario)
De la carpeta libreriasWebServices en la dirección /opt/ GESTION_TESIS
/Jboss-5.1.0.GA/lib/endorsed/ (Reemplazar si es necesario).
9. ARRANQUE DE LA APLICACIÓN
Una vez realizadas las instalaciones y configuraciones debidas, en un terminal se
procede a ejecutar los siguientes comandos, para levantar los servicios de las
aplicaciones:
28
./run.sh (debe estar dentro de la dirección: /opt/GESTION_TESIS/JBoss-
5.1.0.GA/bin)
service alfresco start
1
Anexo
C
MANUAL DE EJECUCIÓN DELPROGRAMA FUENTE
2
Tabla de contenido
1 IDE DE DESARROLLO ECLIPSE ..................................................................... 3
1.1 Instalación de JBoss Seam ............................................................................ 3
2 CREACIÓN DE ESPACIOS DE TRABAJO ...................................................... 3
3 CREACIÓN/RESTAURACIÓN BASE DE DATOS .......................................... 3
4 ADMINISTRACION USUARIOS ...................................................................... 4
5 GENERACIÓN DEL PROCESO DE GESTION DE TESIS .............................. 6
3
1 IDE DE DESARROLLO ECLIPSE
Para instalar la herramienta Eclipse se siguen los siguientes pasos:
1. Descomprimir el paquete del CD: /instaladores-base/eclipse-jee-ganymede-
SR2-linux-gtk.tar.gz en la dirección /opt/GESTION_TESIS, lo cual creara
automáticamente la carpeta /opt/ GESTION_TESIS /eclipse.
2. Descomprimir el paquete del CD: /instaladores-base/ JBossTools-ALL-
linux-gtk-3.0.3.v200910211631N-H194-GA en la dirección /opt/, lo cual
creara automáticamente la carpeta /opt/eclipse.
3. Copiar los archivos de la dirección /opt/eclipse en la direccion /opt/
GESTION_TESIS /eclipse. (Reemplazar si es necesario)
4. En la terminal ejecutar lo siguiente:
cd /opt/GESTION_TESIS/eclipse/
./eclipse --vm /opt/jdk1.6.0_45/bin/java
1.1 Instalación de JBoss Seam
Para el correcto funcionamiento de Eclipse, ademas se requiere extraer el fichero del
CD: /instaladores-base/ jboss-seam-2.2.0.GA.zip en la dirección /opt/
GESTION_TESIS/ (en caso de no existir la carpeta GESTION_TESIS crearla).
2 CREACIÓN DE ESPACIOS DE TRABAJO
Antes de proceder al desarrollo, se requieren de los espacios de trabajo, disponibles
en el CD: /fuentes/workspace cuyo contenido debe ser pegado respectivamente en la
dirección /opt/ GESTION_TESIS. (En caso de no existir el directorio crearlo)
3 CREACIÓN/RESTAURACIÓN BASE DE DATOS
En esta sección, se procederá a la creación y restauración de las bases de datos que
requiere el proyecto.
4
El procedimiento se apoya en archivos .sql que están disponibles en el CD:
/configuraciones/script-db.
Los pasos a seguir se detallan a continuación:
1. Colocar los archivos .sql en la siguiente dirección: /opt/
GESTION_TESIS/script-db (Crear en el caso de que no exista).
2. En un terminal, ejecutar el siguiente comando (Cuando sea requerido, colocar
la clave root):
/opt/PostgreSQL/9.3/bin/psql -U postgres -f /opt/GESTION_TESIS/script-
db/crear-base.sql
3. A continuación ejecutar los siguientes comandos:
Restauración de la base principal de Bonita
/opt/PostgreSQL/9.3/bin/pg_restore --host localhost --port 5432 --username
"postgres" --dbname "bonita_history" --verbose
"/opt/GESTION_TESIS/script-db/bonita_history.backup"
Restauración de la base historial de Bonita
/opt/PostgreSQL/9.3/bin/pg_restore --host localhost --port 5432 --username
"postgres" --dbname "bonita_journal" --verbose
"/opt/GESTION_TESIS/script-db/bonita_journal.backup"
Restauración de la base de gestiontesis
/opt/PostgreSQL/9.3/bin/pg_restore --host localhost --port 5432 --username
"postgres" --dbname "gestiontesis" --verbose "/opt/GESTION_TESIS/script-
db/gestiontesis.backup"
4 ADMINISTRACION USUARIOS
En esta forma de instalación, se partirá del código fuente del sistema GESTION
TESIS disponible en /opt/ GESTION_TESIS
5
El procedimiento se detalla a continuación:
1. Abrir el IDE, en el directorio /opt/ GESTION_TESIS/eclipse, para lo cual
ejecutar en una terminal lo siguiente:
cd /opt/GESTION_TESIS/eclipse/
./eclipse –vm /opt/jdk1.6.0_45/bin/java
2. Elegir como espacio de trabajo /opt/ GESTION_TESIS/workspace.
3. Establecer el jdk en el proyecto para lo cual damos clic derecho en cada
proyecto, seleccionar Build Path Configure Build Path y seleccionar el
JDK nuevo tal como y clic en OK en la figura.
4. Una vez abierto Eclipse, se procede a la generación del fichero ejecutable .ear
requerido. Sobre el proyecto gestiontesis-ear dar clic derecho y elegir Export.
6
A continuación se presentará un cuadro de diálogo donde se debe elegir, de la
carpeta Java EE la opción EAR file.
5. En la sección Destination digitar la dirección
/opt/GESTION_TESIS/gestiontesis-ear.ear y pulsar Finish.
6. El archivo generado /opt/GESTION_TESIS/gestiontesis-ear.ear pegarlo en la
dirección /opt/ GESTION_TESIS/ jboss-5.1.0.GA
/server/default/deploy.(Reemplazar si es necesario)
5 GENERACIÓN DEL PROCESO DE GESTION DE TESIS
El procedimiento para editar y generar el proceso de GESTION_TESIS se apoya en
los ficheros GESTION_TESIS--1.1.war, Calificar_Documento--1.1.war,
Registro_Estudiante--1.1.war y Revision_Oficio_Defensa_Oral--1.1.war, ambos
ubicados en el CD en la dirección /ejecutables-precompilados/.
Los pasos para la edición y compilación del proceso se presentan a continuación:
7
1. Copiar los archivos GESTION_TESIS--1.1.war, Calificar_Documento--
1.1.war, Registro_Estudiante--1.1.war y Revision_Oficio_Defensa_Oral--
1.1.war y pegarlos en la dirección /opt/GESTION_TESIS/ Jboss-5.1.0.GA
/server/default/deploy.
2. Arrancar la plataforma BPM con los siguientes comandos:
Abrir una terminal
Debemos direccionar en la carpeta del Servidor Jboss, para lo cual
ejecutamos en la terminal lo siguiente:
cd /opt/GESTION_TESIS/JBoss-5.1.0.GA/bin
Para poder arrancar el Jboss se debe primero conceder permisos para lo
cual ejecutamos en la terminal lo siguiente:
chmod 777 run-sh
Ejecutar a continuación lo siguiente:
./run.sh
Esperar unos minutos hasta que el servidor termine de subirse y aparezcaal final lo siguiente:
3. Ingresar a la dirección http://localhost:8180/bonita, ingresar con el usuario
admin y la clave admin, y elegir la opción Procesos de la sección Admin.
4. Cambiar el idioma a español en la pestaña ubicada en la parte superior
derecha.
5. Eliminar la versión anterior del proceso, seleccionando los procesos
GESTION_TESIS, Calificar_Documento, Registro_Estudiante y
Revision_Oficio_Defensa_Oral de la sección Lista de todos los procesos,
luego pulsaro en Más acciones y finalmente en Remover. (En caso de existir
los procesos antes mencionados)
8
6. Pulsar el botón Instalar en la sección Lista de todos los procesos. Pulsar
Examinar para localizar los archivos .bar del proceso de Gestión Tesis,
ubicados en el directorio /opt/Desarrollo/bar-generados/process y luego
pulsar Instalar, realizar este procedimiento con los dos achivos
GESTION_TESIS, Calificar_Documento, Registro_Estudiante y
Revision_Oficio_Defensa_Oral
7. Para que se pueda acceder remotamente a los procesos, verificar que en la
pestaña Admin opción Configuración, se encuentren los procesos publicados
con la dirección ip del servidor donde se ecuentra alojado la PlataformaBPM,
como se muestra a continuación.
1
Anexo
D
MANUAL DE USUARIO
2
Tabla de contenido
1. Gestión Administrativa del Sistema ....................................................................... 4
1.1. Seguridades........................................................................................................ 4
1.1.1. Roles ............................................................................................................ 4
1.1.2. Usuarios ...................................................................................................... 5
1.1.3. Asignación de roles a usuarios.................................................................. 6
1.1.4. Asignación de funciones a un rol.............................................................. 7
1.2. Lista Valores...................................................................................................... 9
1.2.1. Facultades................................................................................................... 9
1.2.2. Escuelas ...................................................................................................... 9
1.2.3. Carreras.................................................................................................... 10
1.2.4. Empleados ................................................................................................ 11
1.2.5. Profesores ................................................................................................. 12
1.2.6. Áreas Académicas.................................................................................... 14
1.2.7. Asignación Carrera a un Profesor ......................................................... 15
1.2.8. Documentos .............................................................................................. 16
3.1. Reportes ........................................................................................................... 17
2. Ejecución del flujo del Sistema de Gestión de Tesis............................................ 18
2.1. Iniciación de un caso......................................................................................... 19
2.2. Registrar datos del estudiante y registro del plan de tesis ................................ 20
2.3. Subir plan de tesis ............................................................................................. 22
2.4. Revisar Plan de tesis ......................................................................................... 23
2.5. Aprobación/Negación del Plan de tesis ............................................................ 23
2.6. Elección del Tipo de asignación del Tutor ....................................................... 24
2.7. Elección del Tutor............................................................................................. 25
3
2.8. Registro de Tutorías.......................................................................................... 26
2.9. Tribunal Calificador del Documento de Tesis .................................................. 28
2.10. Calificación del Documento de Tesis............................................................ 30
2.11. Visualizar Documentos Adicionales ............................................................. 31
2.12. Defensa Oral.................................................................................................. 32
2.13. Aprobación de la Defensa Oral ..................................................................... 34
2.14. Registro Final de Notas ................................................................................. 35
2.15. Registro del Folio .......................................................................................... 35
4
1. Gestión Administrativa del Sistema
En la Gestión administrativa esta categorizada en grupos que son:
Seguridades Lista Valores
Reportes Plataforma BPM Repositorio Alfresco
Los cuáles serán descritos a continuación:
Figura 74. Pantalla Principal Sistema
1.1. Seguridades
1.1.1. Roles
La pantalla nos permite visualizar los Roles existentes para el sistema de Gestión de
tesis.
5
Figura 75. Pantalla de Roles
1.1.2. Usuarios
Crear un Usuario.
1. Ingresar a la parte administrativa del sistema de gestión de tesis.2. Seleccionar el “Tipo Usuario” (Empleado, Profesor)
Figura 76. Pantalla Administración Usuario (Tipo Usuario)
3. De acuerdo al “Tipo de Usuario” se debe elegir el Empleado o Profesor.
Figura 77. Pantalla Administración Usuario (2)
4. Una vez elegido el Profesor o usuario, de clic en “Transmitir”.
Figura 78. Pantalla Administración Usuario (3)
6
5. Al “transmitir” se guarda el usuario y además será notificado vía correoelectrónico para que complete su registro, ingresando la contraseña.
Figura 79. Pantalla Mensaje Guardar
Cambiar Estado.
1. Ingresamos a la pantalla de usuarios.2. Damos clic en “Cambiar Estado” en usuario que se desea cambiar su estado,
si está en estado “Inactivo” se cambiara a “Activo” y viceversa.
Figura 80. Pantalla Administración Usuario (Cambiar estado)
1.1.3. Asignación de roles a usuarios
Asignación
1. Ingresamos a la pantalla de “Asignación de Roles a Usuarios”.
Figura 81. Pantalla Cesión Roles a Usuario (1)
2. A continuación seleccionar “Roles”.
7
Figura 82. Pantalla Cesión Roles a Usuario (2)
3. Luego seleccionar los “Usuarios”
Figura 83. Pantalla Cesión Roles a Usuario (3)
4. Una vez seleccionados los “Roles” y “Usuarios”, damos clic en “Transmitir”.
Figura 84. Pantalla Cesión Roles a Usuario (4)
5. Al momento de “Transmitir”, se guardara.
Figura 85. Pantalla Mensaje Guardar
1.1.4. Asignación de funciones a un rol
1. Ingresar a la pantalla de “Asignación de Funciones a un Rol”
8
Figura 86. Pantalla Asignación Funciones a Rol (1)
2. Seleccionar el “Rol” y la “Función”
Figura 87. Pantalla Asignación Funciones a Rol (2)
3. Una vez elegidos, se da clic en “Transmitir”.
Figura 88. Pantalla Asignación Funciones a Rol (3)
4. Al Transmitir se registrara la asignación y se presentara el mensaje:
Figura 89. Pantalla Mensaje Guardar
9
1.2. Lista Valores
1.2.1.Facultades
Crear Facultad
1. Se ingresa a la lista de valores de “Facultad”
2. Damos clic en “Nuevo”
3. Ingresamos la facultad
Figura 90. Pantalla Facultad (1)
4. Damos clic en “Guardar” y se registra la facultad.
Figura 91. Pantalla Mensaje Guardar
Nota: Para editar damos clic en “Editar”, modificamos el texto y damos clic en
“Actualizar”.
1.2.2.Escuelas
1. Se ingresa a la lista de valores de “Escuelas”
2. Damos clic en “Nuevo”
3. Seleccionamos la Facultad.
Figura 92. Pantalla Escuela (1)
4. Ingresamos la Escuela
10
Figura 93. Pantalla Facultad (2)
5. Damos clic en “Guardar”, se registrara y se mostrara el mensaje
Figura 94. Pantalla Mensaje Guardar
1.2.3. Carreras
1. Se ingresa a la lista de valores de “Carreras”
2. Damos clic en “Nuevo”
3. Seleccionamos la Escuela
Figura 95. Pantalla Carreras (1)
4. Ingresamos la Carrera
Figura 96. Pantalla Carreras (2)
11
1.2.4. Empleados
Crear Empleado
1. Ingresamos a “Lista Valores” --> “Empleados”
2. Seleccionamos la Facultad, la Escuela y la Carrera correspondiente.
Figura 97. Pantalla Empleados (1)
3. A continuación ingresamos la cédula, los apellidos, nombres y el correo
electrónico de los empleados.
Figura 98. Pantalla Empleados (2)
4. Una vez completados los datos, damos clic en “Guardar”.
Figura 99. Pantalla Mensaje Guardar
12
Carga Masiva Empleados
1. Ingresamos a “Lista Valores” --> “Empleados”
2. Damos clic en “Añadir”, para poder seleccionar un archivo con formato .xls
que tenga el formato correcto.
Figura 100. Pantalla Carga Masiva Empleados
3. Una vez añadido el archivo, procedemos a dar clic en “Ejecutar Proceso”. Y
se presenta el mensaje:
Figura 101. Pantalla Mensaje Guardar
En caso de existir errores se visualizaran en la parte inferior.
1.2.5. Profesores
Crear Profesor
1. Ingresamos a “Lista Valores” --> “Profesores”
2. Seleccionamos el Área Académica a la cual pertenece el profesor.
Figura 102. Pantalla Administración Profesor (1)
3. Ingresamos la cédula, los apellidos, los nombres y el mail del profesor.
13
Figura 103. Pantalla Administración Profesor (2)
4. Una vez ingresado los datos, damos clic en “Guardar”.
Figura 104. Pantalla Administración Profesor (3)
5. En caso de Existo se presenta el mensaje:
Figura 105. Pantalla Mensaje Guardar
Carga Masiva Profesores
1. Ingresamos a “Lista Valores” --> “Profesores”
2. Damos clic en “Añadir”, para poder seleccionar un archivo con formato .xls -
-que tenga el formato correcto.
14
Figura 106. Pantalla Carga Masiva Profesores
3. Una vez añadido el archivo, procedemos a dar clic en “Ejecutar Proceso”. Y
se presenta el mensaje:
Figura 107. Pantalla Mensaje Guardar
En caso de existir errores se mostraran en la parte inferior de la pantalla.
1.2.6. Áreas Académicas
1. Ingrese a la pantalla de “Área Académica”
Figura 108. Pantalla Área Académica (1)
2. Damos clic en “Nuevo”
15
Figura 109. Pantalla Área Académica (2)
3. Ingresamos el área académica
Figura 110. Pantalla Área Académica (3)
4. Damos clic en “Guardar”
Figura 111. Pantalla Área Académica (4)
5. Si es exitoso se muestra el mensaje:
Figura 112. Pantalla Mensaje Guardar
1.2.7. Asignación Carrera a un Profesor
1. Ingresamos a la pantalla “Asignación carrera a un profesor”.
16
Figura 113. Pantalla Asignación Profesor a una Carrera (1)
2. Seleccionamos la Facultad, la Escuela, la Carrera y el Profesor.
Figura 114. Pantalla Asignación Profesor a una Carrera (2)
3. Una vez completada la selección, damos clic en “Guardar”.
Figura 115. Pantalla Asignación Profesor a una Carrera (3)
4. Completado la acción guardar, se muestra el mensaje:
Figura 116. Pantalla Menaje Guardar
1.2.8. Documentos
1. Ingresamos a la pantalla “Documentos”
17
Figura 117. Pantalla de Administración Documentos (1)
2. Seleccionamos la Facultad, la Escuela, la Carrera, el departamento, el
documento, ingresamos la abreviatura del documento y el secuencial actual.
Figura 118. Pantalla de Administración Documentos (2)
3. Una vez completada la información anterior, damos clic en “Guardar”, y se
mostrara el mensaje.
Figura 119. Pantalla Mensaje Guardar
3.1. Reportes
1. Ingresamos a la pantalla de “Reportes” “Generador de Reportes”.
18
Figura 120. Pantalla Generador de Reportes (1)
2. En la pantalla “Generador de Reportes”, podemos generar los siguientes
reportes:
Listado de Estudiantes.
Estudiantes Graduados.
Los Planes de Tesis de tesis que están aprobados, pendientes y
rechazados.
Las Tesis asignadas a un profesor, cuando es tutor y revisor.
Figura 121. Pantalla Generador de Reportes (2)
Los mismos que son generados en formato PDF, para la facilidad de guardar y/o
imprimir.
2. Ejecución del flujo del Sistema de Gestión de Tesis
En la siguiente sección se muestra todo el flujo que desempeñan cada uno de los actores
en el Procedimiento de Gestión de Tesis establecido por la Facultad de Jurisprudencia.
A continuación se muestra el Flujo de la Gestión de la Tesis, desde que el estudiante
solicita aprobación de la tesis hasta considerarse como graduado; esto a su vez se
presenta como Manual de Usuario para todos los actores del Proceso.
19
2.1. Iniciación de un caso
El proceso es iniciado por el Iniciador (Secretaria de Dirección de Carrera), queingresará sus credenciales dentro del Sistema, a continuación se presenta la pantalla deinicio del mismo:
Figura 122. Pantalla Inicial Plataforma BPM
El Usuario que inicia un caso el aquel que tiene asignado el rol
SECRETARIAESCUELA, este rol debe ser asignado a las personas que trabajan en la
secretaria de cada facultad.
Para iniciar un caso en el menú izquierdo, seleccionar el Proceso GESTION TESIS
Figura 123. Pantalla Menú Procesos
Luego se muestra un boton en la parte central de la pantalla, que dice “Iniciar Caso”,
dar clic en este botón para iniciar el proceso.
20
Figura 124. Pantalla Iniciar un Caso
2.2.Registrar datos del estudiante y registro del plan de tesisUna vez iniciado el proceso se visualiza la pantalla que permite registrar los datos del
estudiante, en donde se selecciona la Escuela, la Carrera; en este caso Escuela
Jurisprudencia, y Carrera de Derecho. Además ingresamos la cedula, nombres y
apellidos, correo electrónico, la fecha en la que egreso el estudiante y que ha
completado la malla Curricular.
Una vez completo los datos del estudiante, damos clic en CONTINUAR, para poder
continuar con el proceso.
Figura 125. Pantalla Registro Datos Estudiante
Luego de dar clic en CONTINUAR, se presenta el siguiente mensaje:
21
Figura 126. Pantalla Mensaje Registro Exitoso
A continuación se procede con el registro del plan de tesis, para lo cual se genera de
manera automática el número de trámite y se ingresa el Título del plan de tesis, una
descripción corta, la descripción de la tesis, si entrega la solicitud y los documentos
necesarios.
Una vez completada la información se procede a dar clic en CONTINUAR , para
continuar con el proceso.
Figura 127. Pantalla Registro Plan Tesis
Paso siguiente se presenta el siguiente mensaje y damos clic en ACEPTAR:
Figura 128. Pantalla Mensaje Registro Exitoso
22
Nota: Además de registrar los datos del estudiante, registrar el plan de tesis, se crear el
usuario que permite ingresar al sistema y se envía un correo electrónico al estudiante
para realice el registro de la contraseña y así poder acceder al sistema para continuar con
el proceso.
2.3. Subir plan de tesis
El proceso continua, ahora es necesario subir el archivo de plan de tesis por parte del
estudiante, para lo cual ingresa al sistema con el usuario(cédula) y contraseña. Luego
da clic en Acceder.
A continuación seleccionar PLATAFORMA BPM y le direcciona a la plataforma en la
que le solicita ingresa el usaurio y contraseña nuevamente.
Una vez que haya ingresado en la bandeja de entrada se observa la tarea que tiene
pendiente, damos clic en la tarea donde se visualiza la pantalla para subir el plan de
tesis.
Damos clic en seleccionar archivo, seleccionamos el archivo en formato PDF que no
exceda de 2MB y clic en Subir, quedando como en la siguiente figura:
Figura 129. Pantalla Subir Plan Tesis
Una vez subido el archivo damos clic en CONTINUAR, para seguir con el proceso y
se peresenta el mensaje siguiente:
23
Figura 130. Pantalla Mensaje Subida Exitosa
2.4.Revisar Plan de tesisEl proceso continua, ahora es necesario la revisión del plan de tesis por parte del
PREREVISOR.
En esta tarea el Prerevisor revisa el plan de tesis, y debe establecer si el plan esta
correcto, escribir algun comentario u observación y subir el archivo de observaciones,
en el caso de seleccione SI se dirige al Director de Carrera para la aprobación; caso
contrario si selecciona NO se direcciona nuevamente al estudiante para que realice los
cambios de acuerdo a las observaciones.
Figura 131. Pantalla Revisión Pre revisor
Cuando se seleccionó NO el estudiante debe subir nuevamente el archivo, tal como en
el punto anterior (Subir plan de Tesis).
2.5.Aprobación/Negación del Plan de tesis
En este proceso, es necesario la aprobaciíon del pla de teesis por parte del Director de
Carrera, para ello ingresamos al sistema con el usuario y contraseña y clic en Ingresar.
24
Una vez dentro del sistema damos clic en PLATAFORMA BPM, y nos direcciona a
la plataforma, ingresamos nuevamente usuario y contraseña.
Donde se visualiza la tarea, damos clic y se visualiza la siguiente pantalla, en donde se
muestra el nombre del estudiante, el titulo de tesis, las observaciones del Prerevisor; en
donde el Director de Carrera determina la viabilidad del mismo; teniendo las opciones
de APROBADO o REPROBADO , seleccionar una de las dos opciones y dar clic en
CONTINUAR.
Figura 132. Pantalla Aprobación Tesis
NOTA: Cuando seleccione APROBADO, se envia un correo electrónico al estudiante
indicando que su tema de tesis ha sido aprobado y que se procedera a la eleccion del
Tutor; caso contrario si selecciona REPROBADO se notifica al estudiante que su tema
ha sido negado y se termina el proceso.
2.6.Elección del Tipo de asignación del TutorEn este proceso, el Director de Carrera tiene que elegir el área de la tesis y el tipo de
asignación del tutor quiere realizar; si es AUTOMATICA o MANUAL, tal como en la
pantalla siguiente:
25
Figura 133. Pantalla Elección tipo de asignación Tutor
NOTA: Si se elige AUTOMATICA, se selecciona de manera automática el tutor y se
notifica a su correo; en caso de que se MANUAL se continua a la tarea de Elección del
tutor.
2.7.Elección del TutorEn este proceso, el Director de Carrera procede con la asignación del tutor para la tesis
de grado, en donde selecciona el docente de la lista de acuerdo al área seleccionada en la
tarea anterior. Una vez seleccionado el docente y marcado el check de tutor, damos clic
en ASIGNAR TUTOR, y clic en FINALIZAR ASIGNACION.
Figura 134. Pantalla Asignación Tutor
Y el Director de Carrera visualiza el oficio que se enviara al tutor, tal como en la
siguiente pantalla:
26
Figura 135. Pantalla Visualizar Oficio Asignación Tutor
NOTA:Una vez terminada la asignacion se emite un correo al Docente notificandole
que ha sido elegido como tutor.
2.8.Registro de TutoríasEn este proceso, actúan los siguientes actores: estudiante y Tutor.
El Tutor revisa el oficio emitido por el Director de Carrera y comienza las Tutorías al
dar clic en COMENZAR TUTORIAS, tal como la siguiente pantalla:
Una vez comenzada las tutorias, se debe registrar cada una de las tutorias, tal como en la
pantalla, en donde se registra lo siguiente:
Las actividades realizadas.
Las actividades pendientes.
El número de horas de tutoría.
Fecha de la Proxima revisión.
Si la Tesis esta terminada.
Subir el archivo de Observaciones del tutor
27
Figura 136. Pantalla Registro de Tutorías
CASO: TUTORIA NO TERMINADA
El estudiante será notificado que tiene correcciones por realizar sobre la tesis; el
estudiante ingresa a la plataforma y realiza las correcciones de la tesis y sube el nuevo
archivo para la revisión, como en la pantalla siguiente:
Figura 137. Pantalla Corrección Tesis
Y continúa con el proceso de revisión, y así sucesivamente hasta que la tesis esté
terminada y que las horas de tutoría este completas.
28
CASO: TUTORIA TERMINADA (Tesis terminada y horas de tutoría
completadas)
Si la tesis está terminada y se ha completado las horas de tutoría, se da clic en
GENERAR CERTIFICADO, como en la pantalla siguiente; donde damos clic en
CONTINUAR para proseguir con la siguiente tarea (Solicitar Tribunal Calificador
Documento).
Figura 138. Pantalla Certificado de Idoneidad
NOTA: Al generar el Certificado de Idoneidad, se notificara al estudiante de que ha
culminado las tutorías.
2.9.Tribunal Calificador del Documento de Tesis
Solicitar Tribunal Calificador
En este proceso, el Estudiante emite la solicitud de asignación del Tribunal Calificador
del Documento, a la Secreataria de Carrera, y damos clic en CONTINUAR.
Figura 139. Pantalla Solicitud Tribunal calificador
Recepción de la Solicitud del Tribunal
29
En esta tarea, La Secretaria de Carrera recepta la solicitud de tribunal calificador del
documento de tesis y a su vez marca si ha recibido el derecho, y procedemos a dar clic
en CONTINUAR.
Figura 140. Pantalla Recepción Tribunal
Revisión de la Solicitud del Tribunal
En el proceso a continuación, El Director de Carrera revisa la solicitud de asignación
del tribunal calificador, y da clic en CONTINUAR.
Figura 141. Pantalla revisión Tribunal calificador
Asignación del Tribunal Calificador
En este proceso, el Director de Carrera procede a asignar los miembros que
conformaran el tribunal calificador del documento de tesis, para lo cual selecciona el
docente y da clic en ASIGNAR; el número establecido de miembros del tribunal está
dado por la regla de negocio (en este caso dos miembros).
Una vez finalizado la elección se da clic en FINALIZAR ASIGNACION, para
continuar con el proceso.
30
Figura 142. Pantalla Asignación tribunal calificador
Verificación del Oficio de Asignación del Tribunal Calificador
En este proceso, el Director de Carrera visualiza si el oficio de asignación de tribunal
calificador está correcto; en caso de no estar correcto se marca NO, se da clic en
CONTINUAR y se direcciona a al proceso anterior (Asignación del Tribunal
Calificador) y si el documento está correcto se marca SI, damos clic en
CONTINUAR y se continua con el proceso.
Figura 143. Pantalla Verificación Oficio Asignación Tribunal
2.10. Calificación del Documento de TesisEn este proceso, después de visualizar el oficio de asignación por parte de los miembros
del tribunal, procede cada uno de los miembros del tribunal a revisar el documento; en
el caso de no existir observaciones cada uno de los miembros procede a calificar el
31
documento de tesis, en donde se ingresa la calificación y se da clic en ENVIAR
CALIFICACION, dando continuidad con el proceso.
Figura 144. Pantalla Calificación Documento
2.11. Visualizar Documentos AdicionalesEn este proceso, el Estudiante podrá descargarse los formularios adicionales y
necesarios tales como:
o Oficio de calificación del documento de tesis.
o Formulario de notas de calificación del documento.
o Documento de Autorización de autoría intelectual.
NOTA: Una vez descargado los documentos procedemos a dar clic en CONTINUAR,
para continuar con el proceso.
32
Figura 145. Pantalla Visualizar Documentos Adicionales
2.12. Defensa OralSolicitud Tribunal de Defensa Oral
En este proceso, cuyo actor es el Estudiante en la cual visualiza la solicitud que se
enviara para solicitar el tribunal para la defensa oral, y dar clic en SOLICITAR
TRIBUNAL, para continuar con el proceso.
Figura 146. Pantalla Solicitud Tribunal Defensa Oral
33
Recepción Solicitud Tribunal Defensa Oral
En el proceso, el actor es la Secretaria de la Carrera encargada de la recepción de la
solicitud para la asignación del tribunal para la defesa oral, y debe receptar el derecho y
marcar con SI y dar clic en CONTINUAR.
Figura 147. Pantalla Recepción Solicitud Defensa Oral
Revisión de la Solicitud del Tribunal Defensa Oral
En este proceso, la Secretaria de Decanato es la encargada de verificar si cumple todos
los requerimientos necesarios, para lo cual debe marcar en cada uno de los check y al
final dar clic en ENVIAR COMPROBACION, y se continúa con el proceso.
Figura 148. Pantalla Comprobación Requisitos
A continuación el Director de Carrera, revisa la solicitud de asignación del tribunal para
la defensa oral, da clic en CONTINUAR, para proseguir con el proceso.
34
Figura 149. Pantalla Revisión Asignación Tribunal Defensa Oral
Asignación del Tribunal, establecer fecha y hora de Defensa Oral
En este proceso los miembros del tribunal de la defensa oral son el mismo, que se
estableció en la asignación del tribunal calificador del documento de tesis, además se
debe establecer la fecha y hora de la defensa oral, esto lo debe realizar el Director de
Carrera y a continuación dar clic en CONTINUAR.
Figura 150. Pantalla Asignación Tribunal Defensa Oral
NOTA: Se le notifica a los miembros de la defensa oral, al estudiante mediante el uso
de correo electrónico con la fecha y hora de la defensa.
2.13. Aprobación de la Defensa OralEn este proceso, la Secretaria de Decanato registra si aprobó la defensa oral de grado,
marcando SI, y a continuación se da clic en REGISTRAR DEFENSA.
35
Figura 151. Pantalla Aprobación Defensa Oral
2.14. Registro Final de NotasEn este proceso, la Secretaria Abogada ingresa la nota de exposición oral, se sube el
acta de notas previamente escaneado y da clic en REGISTRAR NOTAS, para
continuar con el proceso.
Figura 152. Pantalla Registro de Nota Defensa Oral
2.15. Registro del FolioEn este proceso, la Secretaria Abogada registra el número de Folio, y dar clic en
REGISTRAR FOLIO.
Figura 153. Pantalla Registrar Número de Folio
1
Anexo
E
MANUAL TÉCNICO
2
Tabla de contenido
1 DESCRIPCIÓN DEL WEB SERVICE DE LA PLATAFORMA BPM............. 3
1.1 Wsdl del web service ....................................................................................... 3
1.2 Descripción de los métodos del Web Service ................................................ 21
2 Plantilla de mail para notificaciones .................................................................. 22
3 Modelo de la base de datos ................................................................................ 26
4 Codigo de autentificación para Bonita ............................................................... 27
5 Código de autentificación para Jboss Drools ..................................................... 43
6 Codigo de autentificación de Alfresco............................................................... 51
3
DESCRIPCIÓN DEL WEB SERVICE DE LA PLATAFORMA BPM
Wsdl del web service
This XML file does not appear to have any style information associated
with it. The document tree is shown below.
<definitions xmlns="http://schemas.xmlsoap.org/wsdl/" xmlns:soap
="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://webse
rvices.gestiontesis.uce.org/"xmlns:xsd="http://www.w3.org/2001/X
MLSchema" name="WebServiceUce" targetNamespace="http://webservic
es.gestiontesis.uce.org/">
<types>
<xs:schema xmlns:tns="http://webservices.gestiontesis.uce.org/"
xmlns:xs="http://www.w3.org/2001/XMLSchema" targetNamespace="htt
p://webservices.gestiontesis.uce.org/"version="1.0">
<xs:element name="wsCarrera" type="tns:wsCarrera"/>
<xs:element name="wsCarreraResponse" type="tns:wsCarreraResponse
"/>
<xs:element name="wsEscuela" type="tns:wsEscuela"/>
<xs:element name="wsEscuelaResponse" type="tns:wsEscuelaResponse
"/>
<xs:element name="wsFacultad" type="tns:wsFacultad"/>
<xs:element name="wsFacultadResponse" type="tns:wsFacultadRespon
se"/>
<xs:element name="wsGetEmpleado" type="tns:wsGetEmpleado"/>
<xs:element name="wsGetEmpleadoResponse" type="tns:wsGetEmpleado
Response"/>
<xs:element name="wsGetEstudiante" type="tns:wsGetEstudiante"/>
<xs:element name="wsGetEstudianteResponse" type="tns:wsGetEstudi
anteResponse"/>
<xs:element name="wsGetProfesor" type="tns:wsGetProfesor"/>
4
<xs:element name="wsGetProfesorResponse" type="tns:wsGetProfesor
Response"/>
<xs:element name="wsLogeo" type="tns:wsLogeo"/>
<xs:element name="wsLogeoResponse" type="tns:wsLogeoResponse"/>
<xs:element name="wsLogin" type="tns:wsLogin"/>
<xs:element name="wsLoginResponse" type="tns:wsLoginResponse"/>
<xs:element name="wsRoles" type="tns:wsRoles"/>
<xs:element name="wsRolesPorUsuario" type="tns:wsRolesPorUsuario
"/>
<xs:element name="wsRolesPorUsuarioResponse" type="tns:wsRolesPo
rUsuarioResponse"/>
<xs:element name="wsRolesResponse" type="tns:wsRolesResponse"/>
<xs:element name="wsUsuario" type="tns:wsUsuario"/>
<xs:element name="wsUsuarioPorRol" type="tns:wsUsuarioPorRol"/>
<xs:element name="wsUsuarioPorRolResponse" type="tns:wsUsuarioPo
rRolResponse"/>
<xs:element name="wsUsuarioResponse" type="tns:wsUsuarioResponse
"/>
<xs:element name="wsUsuarios" type="tns:wsUsuarios"/>
<xs:element name="wsUsuariosResponse" type="tns:wsUsuariosRespon
se"/>
<xs:complexType name="wsCarrera">
<xs:sequence>
<xs:element name="idEsc" type="xs:int"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsCarreraResponse">
5
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" name="return" ty
pe="tns:item"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="item">
<xs:sequence>
<xs:element name="codigo" type="xs:int"/>
<xs:element minOccurs="0" name="descripcion" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsEscuela">
<xs:sequence>
<xs:element name="idfac" type="xs:int"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsEscuelaResponse">
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" name="return" ty
pe="tns:item"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsFacultad">
<xs:sequence/>
</xs:complexType>
<xs:complexType name="wsFacultadResponse">
6
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" name="return" ty
pe="tns:item"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsGetEmpleado">
<xs:sequence>
<xs:element minOccurs="0" name="idEmp" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsGetEmpleadoResponse">
<xs:sequence>
<xs:element minOccurs="0" name="return" type="tns:persona"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="persona">
<xs:sequence>
<xs:element minOccurs="0" name="apellidos" type="xs:string"/>
<xs:element name="carrera" type="xs:int"/>
<xs:element minOccurs="0" name="cedula" type="xs:string"/>
<xs:element name="escuela" type="xs:int"/>
<xs:element name="facultad" type="xs:int"/>
<xs:element minOccurs="0" name="mail" type="xs:string"/>
<xs:element minOccurs="0" name="nombres" type="xs:string"/>
<xs:element minOccurs="0" name="password" type="xs:string"/>
<xs:element minOccurs="0" name="user" type="xs:string"/>
7
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsGetEstudiante">
<xs:sequence>
<xs:element minOccurs="0" name="idEst" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsGetEstudianteResponse">
<xs:sequence>
<xs:element minOccurs="0" name="return" type="tns:persona"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsGetProfesor">
<xs:sequence>
<xs:element minOccurs="0" name="idProf" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsGetProfesorResponse">
<xs:sequence>
<xs:element minOccurs="0" name="return" type="tns:persona"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsLogeo">
<xs:sequence>
<xs:element minOccurs="0" name="user" type="xs:string"/>
8
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsLogeoResponse">
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" name="return" ty
pe="tns:item"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsLogin">
<xs:sequence>
<xs:element minOccurs="0" name="user" type="xs:string"/>
<xs:element minOccurs="0" name="pass" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsLoginResponse">
<xs:sequence>
<xs:element minOccurs="0" name="return" type="tns:persona"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsRoles">
<xs:sequence/>
</xs:complexType>
<xs:complexType name="wsRolesResponse">
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" name="return" ty
pe="tns:item"/>
9
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsRolesPorUsuario">
<xs:sequence>
<xs:element minOccurs="0" name="user" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsRolesPorUsuarioResponse">
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" name="return" ty
pe="tns:item"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsUsuario">
<xs:sequence>
<xs:element minOccurs="0" name="user" type="xs:string"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsUsuarioResponse">
<xs:sequence>
<xs:element minOccurs="0" name="return" type="tns:persona"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsUsuarioPorRol">
<xs:sequence>
<xs:element minOccurs="0" name="rol" type="xs:string"/>
10
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsUsuarioPorRolResponse">
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" name="return" ty
pe="tns:persona"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="wsUsuarios">
<xs:sequence/>
</xs:complexType>
<xs:complexType name="wsUsuariosResponse">
<xs:sequence>
<xs:element maxOccurs="unbounded" minOccurs="0" name="return" ty
pe="tns:persona"/>
</xs:sequence>
</xs:complexType>
</xs:schema>
</types>
<message name="WebServiceUce_wsUsuarioResponse">
<part element="tns:wsUsuarioResponse" name="wsUsuarioResponse"/>
</message>
<message name="WebServiceUce_wsGetEmpleado">
<part element="tns:wsGetEmpleado" name="wsGetEmpleado"/>
</message>
<message name="WebServiceUce_wsFacultadResponse">
11
<part element="tns:wsFacultadResponse" name="wsFacultadResponse"
/>
</message>
<message name="WebServiceUce_wsLogeoResponse">
<part element="tns:wsLogeoResponse" name="wsLogeoResponse"/>
</message>
<message name="WebServiceUce_wsRoles">
<part element="tns:wsRoles" name="wsRoles"/>
</message>
<message name="WebServiceUce_wsLogeo">
<part element="tns:wsLogeo" name="wsLogeo"/>
</message>
<message name="WebServiceUce_wsLogin">
<part element="tns:wsLogin" name="wsLogin"/>
</message>
<message name="WebServiceUce_wsGetEstudianteResponse">
<part element="tns:wsGetEstudianteResponse" name="wsGetEstudiant
eResponse"/>
</message>
<message name="WebServiceUce_wsUsuarioPorRol">
<part element="tns:wsUsuarioPorRol" name="wsUsuarioPorRol"/>
</message>
<message name="WebServiceUce_wsUsuarioPorRolResponse">
<part element="tns:wsUsuarioPorRolResponse" name="wsUsuarioPorRo
lResponse"/>
</message>
12
<message name="WebServiceUce_wsRolesPorUsuario">
<part element="tns:wsRolesPorUsuario" name="wsRolesPorUsuario"/>
</message>
<message name="WebServiceUce_wsCarrera">
<part element="tns:wsCarrera" name="wsCarrera"/>
</message>
<message name="WebServiceUce_wsEscuela">
<part element="tns:wsEscuela" name="wsEscuela"/>
</message>
<message name="WebServiceUce_wsCarreraResponse">
<part element="tns:wsCarreraResponse" name="wsCarreraResponse"/>
</message>
<message name="WebServiceUce_wsUsuariosResponse">
<part element="tns:wsUsuariosResponse" name="wsUsuariosResponse"
/>
</message>
<message name="WebServiceUce_wsGetEmpleadoResponse">
<part element="tns:wsGetEmpleadoResponse" name="wsGetEmpleadoRes
ponse"/>
</message>
<message name="WebServiceUce_wsUsuarios">
<part element="tns:wsUsuarios" name="wsUsuarios"/>
</message>
<message name="WebServiceUce_wsGetEstudiante">
<part element="tns:wsGetEstudiante" name="wsGetEstudiante"/>
</message>
13
<message name="WebServiceUce_wsFacultad">
<part element="tns:wsFacultad" name="wsFacultad"/>
</message>
<message name="WebServiceUce_wsGetProfesor">
<part element="tns:wsGetProfesor" name="wsGetProfesor"/>
</message>
<message name="WebServiceUce_wsUsuario">
<part element="tns:wsUsuario" name="wsUsuario"/>
</message>
<message name="WebServiceUce_wsGetProfesorResponse">
<part element="tns:wsGetProfesorResponse" name="wsGetProfesorRes
ponse"/>
</message>
<message name="WebServiceUce_wsRolesPorUsuarioResponse">
<part element="tns:wsRolesPorUsuarioResponse" name="wsRolesPorUs
uarioResponse"/>
</message>
<message name="WebServiceUce_wsEscuelaResponse">
<part element="tns:wsEscuelaResponse" name="wsEscuelaResponse"/>
</message>
<message name="WebServiceUce_wsLoginResponse">
<part element="tns:wsLoginResponse" name="wsLoginResponse"/>
</message>
<message name="WebServiceUce_wsRolesResponse">
<part element="tns:wsRolesResponse" name="wsRolesResponse"/>
</message>
14
<portType name="WebServiceUce">
<operation name="wsCarrera" parameterOrder="wsCarrera">
<input message="tns:WebServiceUce_wsCarrera"/>
<output message="tns:WebServiceUce_wsCarreraResponse"/>
</operation>
<operation name="wsEscuela" parameterOrder="wsEscuela">
<input message="tns:WebServiceUce_wsEscuela"/>
<output message="tns:WebServiceUce_wsEscuelaResponse"/>
</operation>
<operation name="wsFacultad" parameterOrder="wsFacultad">
<input message="tns:WebServiceUce_wsFacultad"/>
<output message="tns:WebServiceUce_wsFacultadResponse"/>
</operation>
<operation name="wsGetEmpleado" parameterOrder="wsGetEmpleado">
<input message="tns:WebServiceUce_wsGetEmpleado"/>
<output message="tns:WebServiceUce_wsGetEmpleadoResponse"/>
</operation>
<operation name="wsGetEstudiante" parameterOrder="wsGetEstudiant
e">
<input message="tns:WebServiceUce_wsGetEstudiante"/>
<output message="tns:WebServiceUce_wsGetEstudianteResponse"/>
</operation>
<operation name="wsGetProfesor" parameterOrder="wsGetProfesor">
<input message="tns:WebServiceUce_wsGetProfesor"/>
<output message="tns:WebServiceUce_wsGetProfesorResponse"/>
</operation>
15
<operation name="wsLogeo" parameterOrder="wsLogeo">
<input message="tns:WebServiceUce_wsLogeo"/>
<output message="tns:WebServiceUce_wsLogeoResponse"/>
</operation>
<operation name="wsLogin" parameterOrder="wsLogin">
<input message="tns:WebServiceUce_wsLogin"/>
<output message="tns:WebServiceUce_wsLoginResponse"/>
</operation>
<operation name="wsRoles" parameterOrder="wsRoles">
<input message="tns:WebServiceUce_wsRoles"/>
<output message="tns:WebServiceUce_wsRolesResponse"/>
</operation>
<operation name="wsRolesPorUsuario" parameterOrder="wsRolesPorUs
uario">
<input message="tns:WebServiceUce_wsRolesPorUsuario"/>
<output message="tns:WebServiceUce_wsRolesPorUsuarioResponse"/>
</operation>
<operation name="wsUsuario" parameterOrder="wsUsuario">
<input message="tns:WebServiceUce_wsUsuario"/>
<output message="tns:WebServiceUce_wsUsuarioResponse"/>
</operation>
<operation name="wsUsuarioPorRol" parameterOrder="wsUsuarioPorRo
l">
<input message="tns:WebServiceUce_wsUsuarioPorRol"/>
<output message="tns:WebServiceUce_wsUsuarioPorRolResponse"/>
</operation>
16
<operation name="wsUsuarios" parameterOrder="wsUsuarios">
<input message="tns:WebServiceUce_wsUsuarios"/>
<output message="tns:WebServiceUce_wsUsuariosResponse"/>
</operation>
</portType>
<binding name="WebServiceUceBinding" type="tns:WebServiceUce">
<soap:binding style="document" transport="http://schemas.xmlsoap
.org/soap/http"/>
<operation name="wsCarrera">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</operation>
<operation name="wsEscuela">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</operation>
17
<operation name="wsFacultad">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</operation>
<operation name="wsGetEmpleado">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</operation>
<operation name="wsGetEstudiante">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
18
</output>
</operation>
<operation name="wsGetProfesor">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</operation>
<operation name="wsLogeo">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</operation>
<operation name="wsLogin">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
19
<output>
<soap:body use="literal"/>
</output>
</operation>
<operation name="wsRoles">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</operation>
<operation name="wsRolesPorUsuario">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</operation>
<operation name="wsUsuario">
<soap:operation soapAction=""/>
<input>
20
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</operation>
<operation name="wsUsuarioPorRol">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</operation>
<operation name="wsUsuarios">
<soap:operation soapAction=""/>
<input>
<soap:body use="literal"/>
</input>
<output>
<soap:body use="literal"/>
</output>
</operation>
</binding>
21
<service name="WebServiceUce">
<port binding="tns:WebServiceUceBinding" name="WebServiceUcePort
">
<soap:address location="http://127.0.0.1:8180/ucews/WebServicesB
ean"/>
</port>
</service>
</definitions>
Descripción de los métodos del Web Service
1. wsCarrera(int idEscuela)
Retorna un vector de tipo Item de las carreras pertenecientes a la escuela dada.
2. wsEscuela(int idFacultad)
Retorna un vector de tipo Item de las escuelas pertenecientes a la facultad dada.
3. wsFacultad()
Retorna un vector de tipo Item de las facultades existentes.
4. wsGetEmpleado(String cedEmpleado)
Retorna un empleado de tipo Persona dado la cédula.
5. wsGetEstudiante(String cedEstudiante)
Retorna un estudiante de tipo Persona dado la cédula.
6. wsGetProfesor(int cedProfesor)
Retorna un profesor de tipo Persona dado la cédula.
22
7. wsLogin(String user, String pass)
Retorna un tipo Persona con sus datos, dado el usuario y password.
8. wsProfesor(int idCarrera)
Retorna un vector de tipo Persona de los Profesores de la carrera dada.
9. wsRoles()
Retorna un vector de tipo Item con los roles existentes.
10. wsRolesPorUsuario(String user)
Retorna un vector de tipo Item con los roles que tiene el usuario dado.
11. wsUsuario(String user)
Retorna un tipo Persona con sus datos, dado el usuario.
12. wsUsuarioPorRol(String rol)
Retorna un vector de tipo Persona, con los datos de los usuarios que tengan el rol
dado.
13. wsUsuarios()
Retorna un vector de tipo Persona con sus datos, de todos los usuarios existentes.
Plantilla de mail para notificaciones
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html
xmlns="http://www.w3.org/1999/xhtml"> <head> <title></title> <meta http-
equiv="Content-Type" content="text/html; charset=utf-8" /> <meta http-
equiv="Content-Language" content="en-us" /> <style type="text/css"
media="screen"> /* common --------------------------------------------------*/
body { margin: 0px; padding: 0px; color:
#666; background: #e5e0c9 url("img/bgTile.gif") repeat; } *
#BodyImposter { color: #666; background: #e5e0c9
23
url("img/bgTile.gif") repeat; width: 100%; margin: 0px;
padding: 0px; text-align: center; } * #BodyImposter li, *
#BodyImposter p, * #BodyImposter td { font-size: 12px;
line-height: 1.5em; font-family: Helvetica, Arial, sans-serif;
text-align: justify; } * #BodyImposter p, * #BodyImposter ol, *
#BodyImposter ul { margin: 0em 0em 1em 0em; } * #BodyImposter
img { border: 0px; } * #Primary img { float: right;
margin: 5px 0px 15px 15px; border: 1px solid #d3d3d3;
padding: 6px; } * #BodyImposter small { font-size: 10px;
line-height: 1.3em; } * #BodyImposter ol { padding-
left: 1em; } * #Primary ul { padding-left: 1em;
padding-right: 1em; } * #Secondary ul { padding: 0px; }
* #BodyImposter ol li { margin: 0px; padding: 0px; }
* #BodyImposter ul li { background: url("img/bullet.gif") no-
repeat 0em 0.5em; padding: 0px 0px 0px 8px; margin: 0px;
list-style: none; } /* links -------------------------------------------
-------*/ * #BodyImposter a { text-decoration: underline; }
* #Primary a:link, * #Primary a:visited, * #Secondary a:link, *
#Secondary a:visited { color: #000; background: #fff; }
* #Helpful a:link, * #Helpful a:visited, * #Legal a:link, * #Legal
a:visited { color: #666; background: transparent; } *
#BodyImposter a:hover { text-decoration: none; } *
#BodyImposter a:active { color: #000; background: #fff;
text-decoration: none; } /* heads ------------------------
--------------------------*/ * #BodyImposter h1, * #BodyImposter h2, *
#BodyImposter h3 { color: #945620; background: #fff;
font-family: Georgia, Palatino, serif; font-weight: normal;
line-height: normal; margin: 0em 0em 0.5em 0em;
padding: 0px; text-align: center; } * #Masthead h1 {
font-size: 28px; color: #fff; background: #333;
margin: 0px; } * #Primary h2 { font-size: 22px;
24
background: url("img/ornament.gif") no-repeat center top;
padding-top: 35px; } * #Primary h3 { font-size: 18px;
} * #Secondary h3 { font-size: 16px; text-align:
left; } * #Secondary h3#Issue { padding-top: 40px; }
/* boxes --------------------------------------------------*/ * #Box {
color: #666; background: #fff; border: 1px solid
#d3d3d3; margin: 0px auto; } * #Content { border:
1px solid #d3d3d3; } * #Content td#Primary { background:
url("img/lineV.gif") no-repeat; padding-left: 10px; } *
#Content td#Secondary { background: url("img/lineV.gif") no-repeat
right bottom; padding-right: 10px; } * #Helpful, * #Legal {
margin: 0px auto; } * #Helpful p, * #Legal p { margin:
0px; padding: 0px; text-align: center; } * #Masthead {
color: #fff; background: #333; } * #Masthead h1, *
#Masthead p { text-align: left; } * #Masthead p {
font-size: 14px; margin: 0px; } * #Masthead p #Date {
float: right; } * #Masthead { width: 100%;
text-align: center; } /* The asterisks preceding every selector
ensure styles are rendered in Dot Mac. The inline styles in headlines are for
Outlook 2007. */ </style> </head> <body> <div id="BodyImposter" style="color:
#666; background-color: #e5e0c9;"> <table id="Helpful" cellspacing="0"
cellpadding="15" width="610"> <tr> <td style="font-
family: Helvetica, Arial, sans-serif;"> <p></p>
</td> </tr> </table> <table id="Box" cellspacing="0"
cellpadding="15" width="580" style="color: #666; background-color: #fff;">
<tr> <td> <table id="Masthead"
cellspacing="0" cellpadding="20" width="580">
<tr> <td style="color: #FFFFFF;
background: #285A82; font-family: Helvetica, Arial, sans-serif;">
<h3 style="font-family: Georgia, Palatino,
serif;">SISTEMA DE GESTION DE TESIS.. </h3>
25
</td>
</tr> </table> <table id="Box"
cellspacing="0" cellpadding="15" width="580" style="color: #666; background-
color: #fff;"> <tr> <td> <table
id="Content" cellspacing="0" cellpadding="20" width="580" style="color: #666;
background-color: #fff;"> <tr valign="top">
<td
id="Primary" width="350" style="font-family: Helvetica, Arial, sans-
serif;"> <p>BIENVENIDO</p> <p>Estimado usuario.. ${r_apellidos}
${r_nombre}</p> <p>Una vez que haya completado con la verificación de la clave,
procesa a ingresa a la siguiente direcciòn URL</p> <p>para continuar con el
proceso.</p> <p><a href="localhost:8180/bonita/"> Continuar con el
Proceso</a></p> <p> </p> <p>Gracias por su colaboración.</p>
</td>
</tr> </table> </td>
</tr> </table> <table id="Legal" cellspacing="0" cellpadding="15"
width="610"> <tr> <td style="font-family: Helvetica, Arial,
sans-serif;"> <p><a
href="http://www.uce.edu.ec/">Universidad Central del Ecuador</a></p>
</td> </tr> </table> </div> </body> </htm
26
Modelo de la base de datos
FK_ESCUELA_REFERENCE_FACULTAD
FK_CARRERA_REFERENCE_ESCUELA
FK_ESTUDI_C_REFERENCE_CARRERA
FK_ESTUDI_C_REFERENCE_ESTUDIAN
FK_CARRERA__REFERENCE_CARRERA
FK_CARRERA__REFERENCE_PROFESOR
FK_EMPLEADO_REFERENCE_CARRERA
FK_ACCESO_REFERENCE_PROFESOR
FK_ACCESO_REFERENCE_EMPLEADO
FK_ACCESO_REFERENCE_ESTUDIAN
FK_ACCESO_REFERENCE_TIPO_PER
FK_ACCESO_R_REFERENCE_ACCESO
FK_PERMISOS_REFERENCE_FUNCIONE
FK_PERMISOS_REFERENCE_ROLES
FK_ACCESO_R_REFERENCE_ROLES
FK_DENUNCIA_REFERENCE_ESTUDIAN
FK_DENUNCIA_REFERENCE_TESIS
FK_TESIS_REFERENCE_ESTADO
FK_TUTORIAS_REFERENCE_TESIS
FK_PROF_TES_REFERENCE_PROFESOR
FK_PROF_TES_REFERENCE_TESISFK_PROF_TES_REFERENCE_ROL_PROF
FK_TESIS_REFERENCE_PROCESOS
FK_DOCUMENT_REFERENCE_CARRERA
FK_DOCUMENT_REFERENCE_TESIS
FK_AREA_ACA_REFERENCE_CARRERAFK_PROF_ARE_REFERENCE_AREA_ACA
FK_PROF_ARE_REFERENCE_PROFESOR
FK_TRIBUNAL_REFERENCE_TESIS
FK_TRIBUNAL_REFERENCE_PROFESOR
FACULTAD
ID_FACULTADFACULTAD
SERIALVARCHAR(50)
<pk>
ESCUELA
ID_ESCUELAESCUELAID_FACULTAD...
SERIALVARCHAR(50)INT4
<pk>
<fk>
CARRERA
ID_CARRERACARRERATITULO_REFRENDIDOID_ESCUELA...
SERIALVARCHAR(50)VARCHAR(150)INT4
<pk>
<fk>
ESTUDIANTE
CEDULANOMBRESAPELLIDOSMAILFECHA_EGRESOMALLA_COMPLETA...
VARCHAR(13)VARCHAR(100)VARCHAR(100)VARCHAR(70)DATECHAR(1)
<pk>
ESTUDI_CARRER
ID_ESTU_CARRID_CARRERACEDULA...
SERIALINT4VARCHAR(13)
<pk><fk1><fk2>
EMPLEADOS
CEDULA_EMPID_CARRERANOMBRE_EMPAPELLIDOS_EMPMAIL_EMP...
VARCHAR(13)INT4VARCHAR(255)VARCHAR(255)VARCHAR(70)
<pk><fk>
CARRERA_PROFE
ID_CARR_REVID_CARRERACEDULA_PROF...
SERIALINT4VARCHAR(13)
<pk><fk1><fk2>
PROFESORES
CEDULA_PROFNOMBRE_PROFAPELLIDOS_PROFMAIL_PROF...
VARCHAR(13)VARCHAR(50)VARCHAR(50)VARCHAR(50)
<pk>
ACCESO
USUARIOCLAVEESTADOCEDULACEDULA_EMPCEDULA_PROFID_TIPO...
VARCHAR(50)VARCHAR(50)VARCHAR(50)VARCHAR(13)VARCHAR(13)VARCHAR(13)INT4
<pk>
<fk3><fk2><fk1><fk4>
TIPO_PERSONA
ID_TIPOTIPO
SERIALVARCHAR(70)
<pk>
ACCESO_ROL
ID_ACCES_ROLID_ROLUSUARIOESTADO...
SERIALINT4VARCHAR(50)VARCHAR(1)
<pk><fk2><fk1>
ROLES
ID_ROLROLDESCRIPCION
SERIALVARCHAR(50)VARCHAR(50)
<pk>
PERMISOS
ID_PERMISOID_FUNCIONID_ROLESTADO...
SERIALVARCHAR(20)INT4VARCHAR(1)
<pk><fk1><fk2>
FUNCIONES
ID_FUNCIONDESCRIPCION
VARCHAR(20)VARCHAR(200)
<pk>
PARAMETROS
ID_PARAMETROPARAMETROVALOR...
SERIALVARCHAR(50)VARCHAR(50)
<pk>
AD_INGRESOS
USUARIOFECHA_INGRESOHORA_INGRESOEXITOMOTIVO...
VARCHAR(50)DATETIMESTAMP WITH TIME ZONEVARCHAR(1)VARCHAR(150)
<pk><pk><pk><pk><pk>
ESTADO
ID_ESTADOESTADO
SERIALVARCHAR(50)
<pk>
DENUNCIANTE_TESIS
ID_DENUN_TESISMATRICULAENTREGA_SOLICITUDENTREGA_DOCUMENTACIONCEDULAID_TESIS...
SERIALINT4VARCHAR(1)VARCHAR(1)VARCHAR(13)INT4
<pk>
<fk1><fk2>
TESIS
ID_TESISTITULODESCRIPCIONNUMERO_TRAMITENUMERO_OFICIOFECHA_ENTREGAFECHA_APROBACIONFECHA_VENCIMIENTOFECHA_NEGACIONFECHA_ASIGNACION_REVFECHA_ASIGNACION_TUTPROMEDIO_PROMOCIONNOTA_ESCRITONOTA_ORALNOTA_FINALHORASTOTAL_TUTORIAID_ESTADOID_PROCESO...
SERIALVARCHAR(500)VARCHAR(200)VARCHAR(50)VARCHAR(50)TIMESTAMPTIMESTAMPTIMESTAMPTIMESTAMPTIMESTAMPTIMESTAMPDECIMAL(4,2)DECIMAL(4,2)DECIMAL(4,2)DECIMAL(4,2)INT4INT4INT4
<pk>
<fk1><fk2>
TUTORIAS_TESIS
ID_TUTORIASID_TESISTIEMPO_REVISIONFECHA_REVISIONFECHA_PROX_REVISIONRECOMENDACIONESOBSERVACIONES
SERIALINT4DECIMAL(4,2)DATEDATEVARCHAR(255)VARCHAR(255)
<pk><fk>
PROF_TESIS
ID_PROF_TESCEDULA_PROFID_TESISID_ROL_PROFORDEN...
SERIALVARCHAR(13)INT4INT4INT4
<pk><fk1><fk2><fk3>
ROL_PROFESOR_TESIS
ID_ROL_PROFROL_PROF
SERIALVARCHAR(50)
<pk>
AREA_ACADEMICA
ID_AREAID_CARRERAAREA_ACADEMICO...
SERIALINT4VARCHAR(50)
<pk><fk>
REGISTRO_WEB
ID_REGISTROCEDULAGENERADOESTADO...
SERIALVARCHAR(13)VARCHAR(100)VARCHAR(1)
<pk>
DOCUMENTOS_TRAMITES
ID_DOC_TRAMDOCUMENTOABREVIATURA_DOCSECUENCIAL_ACTUALID_CARRERA...
SERIALVARCHAR(20)VARCHAR(10)INT4INT4
<pk>
<fk>
PROCESOS_UCE
IDUUIDPROCESOSUUIDINSTANCIAID_FACULTADESPACIOURL_ESPACIOTEMA...
SERIALVARCHAR(100)VARCHAR(100)INT4VARCHAR(100)VARCHAR(100)VARCHAR(100)
<pk>DOCUMENTOS_TESIS
IDUUIDPROCESOUUIDREVISORESESPACIOURL_ESPACIOTIPO_DOCUMID_TESIS...
SERIALVARCHAR(100)VARCHAR(100)VARCHAR(100)VARCHAR(100)VARCHAR(100)INT4
<pk>
<fk>
AUTORIDADES
ID_AUTORIDADESID_TIPO_PERSONAIDENTIFICACIONID_FACULTADID_ESCUELAID_CARRERACARGO...
SERIALINT4VARCHAR(13)INT4INT4INT4VARCHAR(50)
<pk>
PROF_AREA
ID_AREA_PROFID_AREACEDULA_PROFSECUENCIAL...
SERIALINT4VARCHAR(13)INT4
<pk><fk1><fk2>
TRIBUNAL_TESIS
ID_TRIBID_TESISCEDULA_PROFFECHA_ASIGNACIONNOTA_ESCRITOFECHA_NOTA_ESCRITONOTA_ORALFECHA_NOTA_ORALTIPO...
SERIALINT4VARCHAR(13)DATEDECIMAL(4,2)TIMESTAMPDECIMAL(4,2)TIMESTAMPVARCHAR(10)
<pk><fk1><fk2>
27
Codigo de autentificación para Bonita
Bonita Open Solution, requiere definir las siguientes clases java:
public class DBExternalAuthImpl implements AuthenticationService {
private String persistenceServiceName;
private DBUCE db;
public DBExternalAuthImpl(String persistenceServiceName) {
super();
this.persistenceServiceName = persistenceServiceName;
db=new DBUCE();
}
public DBExternalAuthImpl() {
super();
db=new DBUCE();
}
public boolean checkUserCredentials(String arg0, String arg1) {
try{
return db.checkUserCredentials(arg0, arg1);
28
}
catch(Throwable e){
e.printStackTrace();
}
return false;
}
public boolean isUserAdmin(String arg0) throws UserNotFoundException {
try{
return db.isUserAdmin(arg0);
}
catch(Throwable e){
e.printStackTrace();
}
return false;
}
public boolean checkUserCredentialsWithPasswordHash(String arg0, String
arg1) {
return checkUserCredentials(arg0, arg1);
}
}
public class DBCustomIdentityImpl implements IdentityService {
29
private DBUCE db;
public DBCustomIdentityImpl() {
super();
db = new DBUCE();
}
public static void main(String[] args) {
List<UserImpl> res = new
DBCustomIdentityImpl().getUsersByRole("admin", 0, 100);
for (UserImpl u : res) {
System.out.println(u.getFirstName()+" "+u.getLastName());
}
}
public DBCustomIdentityImpl(String persistenceServiceName) {
super();
db = new DBUCE();
}
public RoleImpl findRoleByName(String arg0) {
return db.getRole(arg0);
}
30
public UserImpl findUserByUsername(String arg0) {
try {
return db.findUser(arg0);
} catch (Throwable e) {
e.printStackTrace();
}
return null;
}
public List<GroupImpl> getAllGroups() {
return new ArrayList<GroupImpl>();
}
public List<RoleImpl> getAllRoles() {
try {
return db.getRoles();
} catch (Throwable e) {
e.printStackTrace();
}
return null;
31
}
public List<UserImpl> getAllUsers() {
try {
return db.getUsers();
} catch (Throwable e) {
e.printStackTrace();
}
return null;
}
public int getNumberOfRoles() {
try {
return db.numRoles();
} catch (Throwable e) {
e.printStackTrace();
}
return 0;
}
public int getNumberOfUsers() {
32
try {
return db.numUsers();
} catch (Throwable e) {
e.printStackTrace();
}
return 0;
}
public int getNumberOfUsersByRole(String arg0) {
try {
return db.numUsersByRol(arg0);
} catch (Throwable e) {
e.printStackTrace();
}
return 0;
}
public RoleImpl getRole(String arg0) {
try {
return db.getRole(arg0);
} catch (Exception e) {
e.printStackTrace();
33
}
return null;
}
public List<RoleImpl> getRoles(Collection<String> arg0) {
List<RoleImpl> r = new ArrayList<RoleImpl>();
for (String s : arg0) {
r.add(getRole(s));
}
return r;
}
public List<RoleImpl> getRoles(int arg0, int arg1) {
List<RoleImpl> res = getAllRoles();
int toIndex = arg1;
if(toIndex > res.size()) toIndex = res.size();
return res.subList(arg0, toIndex);
}
public UserImpl getUser(String arg0) {
try {
return db.getUser(arg0);
34
} catch (Throwable e) {
e.printStackTrace();
}
return null;
}
public List<UserImpl> getUsers(Collection<String> arg0) {
List<UserImpl> r = new ArrayList<UserImpl>();
for (String s : arg0) {
r.add(getUser(s));
}
return r;
}
public List<UserImpl> getUsers(int arg0, int arg1) {
List<UserImpl> res = getAllUsers();
int toIndex = arg1;
if(toIndex > res.size()) toIndex = res.size();
List<UserImpl> usr = res.subList(arg0, toIndex);
return usr;
}
35
public List<UserImpl> getUsersByRole(String arg0) {
try {
return db.getUsers(arg0);
} catch (Throwable e) {
e.printStackTrace();
}
return null;
}
public List<UserImpl> getUsersByRole(String arg0, int arg1, int arg2) {
List<UserImpl> res = getUsersByRole(arg0);
int toIndex = arg2;
if(toIndex > res.size()) toIndex = res.size();
return res.subList(arg1, toIndex);
}
// Los demás métodos se pueden dejar solo declarados pues no se usan en la
//plataforma
}
Las clases presentadas se apoyan en las siguientes clases:
public class DBUCE {
private final String DEFAULT_ADMIN_ROLE_NAME = "admin";
36
private WebServiceUceProxy servicio;
public DBUCE() {
servicio = new WebServiceUceProxy();
servicio.setEndpoint(ReadProperties.endPoint());
}
public boolean checkUserCredentials(String user, String pass) throws Throwable
{
Persona p = servicio.wsLogin(user, pass);
if(p == null) return false;
return true;
}
public boolean isUserAdmin(String arg0) throws Throwable {
Item[] roles = servicio.wsRolesPorUsuario(arg0);
for (Item r : roles) {
if(r.getDescripcion().equals(DEFAULT_ADMIN_ROLE_NAME))
return true;
}
return false;
}
37
public RoleImpl getRole(String arg0) {
RoleImpl r = new RoleImpl(arg0);
r.setLabel(arg0);
r.setDescription(arg0);
try {
Persona[] res = servicio.wsUsuarioPorRol(arg0);
for(Persona t : res){
UserImpl usr = new UserImpl(t.getUser(),
t.getPassword());
usr.setFirstName(t.getApellidos());
usr.setLastName(t.getNombres());
r.addUser(usr);
}
} catch (Throwable e) {
e.printStackTrace();
}
return r;
}
public Set<RoleImpl> getRoles() throws Throwable {
Set<RoleImpl> r = new HashSet<RoleImpl>();
Item[] res = servicio.wsRoles();
for (Item t : res) {
38
r.add(getRole(t.getDescripcion()));
}
return r;
}
public UserImpl getUser(String arg0) throws Throwable {
Persona res = servicio.wsUsuario(arg0);
UserImpl u = new UserImpl(res.getUser(),res.getPassword());
u.setLastName(res.getApellidos());
u.setFirstName(res.getNombres());
u.setRoles(getUserRoles(res.getUser()));
return u;
}
private Set<RoleImpl> getUserRoles(String user) throws Throwable{
Set<RoleImpl> r = new HashSet<RoleImpl>();
Item[] res = servicio.wsRolesPorUsuario(user);
for (Item t : res) {
RoleImpl rol = new RoleImpl(t.getDescripcion());
rol.setLabel(t.getDescripcion());
rol.setDescription(t.getDescripcion());
r.add(rol);
39
}
return r;
}
public Set<UserImpl> getUsers() throws Throwable {
Set<UserImpl> res = new HashSet<UserImpl>();
Persona[] s = servicio.wsUsuarios();
for (Persona t : s) {
UserImpl u = new UserImpl(t.getUser(), t.getPassword());
u.setLastName(t.getApellidos());
u.setFirstName(t.getNombres());
u.setRoles(getUserRoles(t.getUser()));
res.add(u);
}
return res;
}
Además depende de una clase, que lee un fichero llamado fichero.properties.
public static final String PATH_PROPS = ".." + File.separator + "server" +
File.separator + "default" +
File.separator + "conf" + File.separator + "fichero.properties";
40
public static String endPoint(){
String endPoint = null;
endPoint = getProperties("endPoint");
if(endPoint == null) endPoint =
"http://localhost:8180/ucews/WebServicesBean?wsdl";
return endPoint;
}
public static String ipAlfresco(){
String endPoint = null;
endPoint = getProperties("hostAlfresco");
if(endPoint == null) endPoint = "localhost";
return endPoint;
}
public static String portAlfresco(){
String endPoint = null;
endPoint = getProperties("portAlfresco");
if(endPoint == null) endPoint = "8080";
return endPoint;
}
public static String ipSmtp(){
41
String endPoint = null;
endPoint = getProperties("hostSmpt");
if(endPoint == null) endPoint = "smtp.gmail.com";
return endPoint;
}
public static String portSmtp(){
String endPoint = null;
endPoint = getProperties("portSmtp");
if(endPoint == null) endPoint = "465";
return endPoint;
}
public static String socketDrools(){
String endPoint = null;
endPoint = getProperties("socketDrools");
if(endPoint == null) endPoint = "http://localhost:8180";
return endPoint;
}
private static String getProperties(String name){
Properties prop = new Properties();
42
InputStream is = null;
try {
is=new FileInputStream(PATH_PROPS);
prop.load(is);
return prop.getProperty(name);
} catch(IOException ioe) {
ioe.printStackTrace();
}
return null;
}
El archivo fichero.properties debe contener las siguientes líneas:
endPoint=http\://localhost\:8180/ucews/WebServicesBean?wsdl
hostAlfresco=localhost
portAlfresco=8080
socketDrools=http://localhost:8180
hostSmpt=smtp.gmail.com
portSmtp=465
NOTA:
43
El archivo fichero.properties, hace referencia a la direccion HTTP del wsdl del Servicio
Web, la dirección IP (o nombre de dominio) y el puerto de escucha del servidor
Alfresco, el socket usado por el motor de reglas Drools, y la dirección IP (o nombre de
dominio) y puerto de escucha del servidor de correo.
Código de autentificación para Jboss Drools
JBoss Drools requiere definir la siguiente clase java para poder modificar el acceso al
Drools:
public class CustomGuvnorLogin implements LoginModule {
private static final String NAME_PROMPT = "user name: ";
private static final String PASSWORD_PROMPT = "password: ";
private static final String JAVAX_SECURITY_AUTH_LOGIN_PASSWORD
= "javax.security.auth.login.password";
private static final String JAVAX_SECURITY_AUTH_LOGIN_NAME =
"javax.security.auth.login.name";
private final String DEFAULT_ADMIN_ROLE_NAME =
"ADMINISTRADOR";
public static final String DEBUG_OPTION_NAME = "debug";
private Subject subject = null;
private CallbackHandler callbackHandler = null;
private Map<String, Object> sharedState;
private boolean debug = false;
private String id;
44
@SuppressWarnings("unchecked")
public void initialize(final Subject subject, final CallbackHandler
callbackHandler,
final Map<String, ?> sharedState, final Map<String, ?> options) {
this.subject = subject;
this.callbackHandler = callbackHandler;
this.sharedState = (Map<String, Object>) sharedState;
final String debugFlag = (String)
options.get(DEBUG_OPTION_NAME);
if (debugFlag != null) {
this.debug = Boolean.valueOf(debugFlag);
}
}
public boolean login() throws LoginException {
if (this.debug) {
System.err.println("[Guvnor] login() - preparing - step 1");
}
try {
String name = (String)
this.sharedState.get(JAVAX_SECURITY_AUTH_LOGIN_NAME);
45
String password = (String)
this.sharedState.get(JAVAX_SECURITY_AUTH_LOGIN_PASSWORD);
final List<Callback> callbacks = new ArrayList<Callback>();
final NameCallback nameCallback = new
NameCallback(NAME_PROMPT);
final PasswordCallback passwordCallback = new
PasswordCallback(PASSWORD_PROMPT, false);
if (name == null) {
callbacks.add(nameCallback);
}
if (password == null) {
callbacks.add(passwordCallback);
}
if (!callbacks.isEmpty()) {
if (this.debug) {
System.err.println("[Guvnor] login() - callback - step 2");
}
this.callbackHandler.handle(callbacks.toArray(new Callback[0]));
if (name == null) {
name = nameCallback.getName();
}
if (password == null) {
46
password = new String(passwordCallback.getPassword());
passwordCallback.clearPassword();
}
}
if (this.debug) {
System.err.println("[Guvnor] login() - authenticating - step 3");
}
if (name != null) {
if(esAdmin(name, password))
id = name;
}
if (this.debug) {
System.err.println("[Guvnor] login() - storing data - step 4");
}
this.sharedState.put(JAVAX_SECURITY_AUTH_LOGIN_NAME, name);
this.sharedState.put(JAVAX_SECURITY_AUTH_LOGIN_PASSWORD,
password);
if (this.debug) {
47
System.err.println("[Guvnor] login() - returning - step 5");
}
if (this.id == null) {
throw new FailedLoginException("id nulo");
}
return true;
} catch (final Exception e) {
e.printStackTrace();
final LoginException le = new LoginException();
le.initCause(e);
throw le;
}
}
private boolean esAdmin(String user, String pass){
try {
WebServiceUceProxy servicio = new WebServiceUceProxy();
servicio.setEndpoint(ReadProperties.endPoint());
Persona p = servicio.wsLogin(user, pass);
if(p == null)
return false;
48
Item[] res = servicio.wsRolesPorUsuario(user);
if(res != null){
for (Item t : res) {
if(t.getDescripcion().equalsIgnoreCase(DEFAULT_ADMIN_ROLE_NAME)){
return true;
}
}
}
} catch (Throwable e) {
e.printStackTrace();
}
return false;
}
public boolean commit() throws LoginException {
if (this.id == null) {
throw new FailedLoginException("No se pudo logear al usuario");
}
49
final Set<Principal> principals = this.subject.getPrincipals();
principals.add(new CustomPrincipal(this.id));
return true;
}
public boolean abort() throws LoginException {
if (this.debug) {
System.err.println("[Guvnor] abort()");
}
if (this.id == null) {
return false;
}
this.subject = null;
this.id = null;
return true;
}
public boolean logout() throws LoginException {
if (this.id != null) {
if (this.debug) {
50
System.err.println("[Guvnor] logout() - removing principals");
}
final Set<Principal> principals = new
HashSet<Principal>(this.subject.getPrincipals());
for (final Principal p : principals) {
if (p instanceof CustomPrincipal) {
if (this.debug) {
System.err.println("[Guvnor] logout() - removing principal: " + p);
}
this.subject.getPrincipals().remove(p);
}
}
if (this.debug) {
System.err.println("[Guvnor] logout() - destroying/removing credentials");
}
final Set<Object> credentials = new
HashSet<Object>(this.subject.getPublicCredentials());
for (final Object o : credentials) {
if (o instanceof Destroyable) {
if (this.debug) {
System.err.println("[Guvnor] logout() - destroying credential: " + o);
}
51
}
if (!this.subject.isReadOnly()) {
if (this.debug) {
System.err.println("[Guvnor] logout() - removing credential: " + o);
}
this.subject.getPublicCredentials().remove(o);
}
}
}
return true; }}
NOTA:
Para poder acceder al drools, debe ser un empleado que tenga el rol de
ADMINISTRADOR
Código de autentificación de Alfresco
Alfresco requiere definir las siguientes clases java, para poder modificar la
autentificación:
public class CustomLoginBean extends LoginBean
{
private static final long serialVersionUID = -208988073976944064L;
private static final Log logger = LogFactory.getLog(CustomLoginBean.class);
52
private final String DEFAULT_ADMIN_ROLE_NAME =
"ADMINISTRADOR";
public String login()
{
String user = getUsername();
String pass = getPassword();
if(!esAdmin(user, pass)){
return null;
}
importarPersona(user, pass);
String outcome = super.login();
if (user == null){
user = "Guest";
}
logger.info(user + " logeado " + new Date()+ "resp: "+outcome);
return outcome;
}
private boolean esAdmin(String user, String pass){
try {
WebServiceUceProxy servicio = new WebServiceUceProxy();
53
servicio.setEndpoint(ReadProperties.endPoint());
Persona p = servicio.wsLogin(user, pass);
if(p == null)
return false;
Item[] res = servicio.wsRolesPorUsuario(user);
if(res != null){
for (Item t : res) {
if(t.getDescripcion().equalsIgnoreCase(DEFAULT_ADMIN_ROLE_NAME)){
return true;
}
}
}
} catch (Throwable e) {
e.printStackTrace();
}
return false;
}
private void importarPersona(String user, String pass){
String nombre = user;
String apellido = user;
54
String email = "[email protected]";
AuthenticationService a = super.getAuthenticationService();
a.authenticate("admin", "admin".toCharArray());
if(!a.authenticationExists(user)){
MutableAuthenticationService f = (MutableAuthenticationService) a;
f.createAuthentication(user, pass.toCharArray());
PersonService p = super.getPersonService();
NodeRef n = new NodeRef("workspace://SpacesStore/03a0590b-
2849-412b-a49a-16d484dc7717");
HashMap<QName, Serializable> properties = new
HashMap<QName, Serializable>();
properties.put(ContentModel.PROP_USERNAME, user);
properties.put(ContentModel.PROP_HOMEFOLDER, n);
properties.put(ContentModel.PROP_FIRSTNAME, nombre);
properties.put(ContentModel.PROP_LASTNAME, apellido);
properties.put(ContentModel.PROP_PASSWORD, pass);
properties.put(ContentModel.PROP_EMAIL, email);
p.createPerson(properties);
logger.info("persona creada: " + user);
}
55
a.invalidateTicket(a.getCurrentTicket(), null);
a.clearCurrentSecurityContext();
}
public String logout()
{
return super.logout();
}
}
La implementación definida, hará que solo algún usuario con rol admininitrador pueda
ingresar a Alfresco. Finalmente, requiere una clase que permite leer propiedades desde
un fichero de nombre fichero.properties.
public class ReadProperties {
public String endPoint(){
String endPoint =
"http://localhost:8180/ucews/WebServicesBean?wsdl";
Properties prop = new Properties();
InputStream is = null;
try {
is=this.getClass().getResourceAsStream("/fichero.properties");
prop.load(is);
56
endPoint = prop.getProperty("endPoint");
} catch(IOException ioe) {
ioe.printStackTrace();
}
return endPoint;
}
}