Download 1 pontificia universidad catolica del ecuador facultad de ingenieria

PONTIFICIA UNIVERSIDAD CATOLICA DEL ECUADOR
FACULTAD DE INGENIERIA
ESCUELA DE SISTEMAS
DISERTACIÓN DE GRADO PREVIA LA OBTENCIÓN DEL TÍTULO DE INGENIERO
EN SISTEMAS Y COMPUTACIÓN
TEMA:
PROPUESTA E IMPLEMENTACIÓN DE UN MODELO PARA CONTROL DE
DOCUMENTOS BASADO EN LA NORMA ISO 9001: 2008, PARA LA EMPRESA
“SOLUCIONES INTEGRALES DE COMPRAS Y ADQUISICIONES (LOGICA)”
AUTORES:
GUSTAVO JUSTICIA
LUCIA DEL PINO
QUITO – ECUADOR
1
DEDICATORIA
A nuestra familia que de una u otra forma nos han apoyado en cada momento de nuestras vidas para
culminar nuestros estudios universitarios y a nuestros profesores que siempre estuvieron ampliando
nuestro conocimiento, respondiendo las inquietudes encontradas en el camino, gracias a ellos
seremos unos profesionales exitosos en la vida
2
AGRADECIMIENTOS
Queremos expresar nuestros más sinceros reconocimientos a todas aquellas personas que nos
ayudaron
en
la elaboración de la tesis tanto técnica como funcional, puesto que con las
observaciones e información obtenida se ha desarrollado un trabajo de alta calidad.
3
TABLA DE CONTENIDO
Contenido
DEDICATORIA ................................................................................................................................. 2
AGRADECIMIENTOS ...................................................................................................................... 3
TABLA DE CONTENIDO ................................................................................................................. 4
INTRODUCCION .............................................................................................................................. 9
ANTECEDENTES ............................................................................................................................ 10
RESUMEN EJECUTIVO ................................................................................................................. 11
JUSTIFICACION ............................................................................................................................. 12
OBJETIVOS ..................................................................................................................................... 13
GENERAL .................................................................................................................................... 13
ESPECIFICOS .............................................................................................................................. 13
ALCANCE ........................................................................................................................................ 14
CAPÍTULO I..................................................................................................................................... 15
1.1.
Introducción ...................................................................................................................... 15
1.1.2
Enfoque basado en procesos ..................................................................................... 16
1.1.3
Relación con la Norma ISO 9004.............................................................................. 18
1.1.4
Compatibilidad con otros sistemas de gestión .......................................................... 19
1.2.
Objetivo y campo de aplicación ........................................................................................ 19
1.3.
Referencias normativas ..................................................................................................... 20
1.4.
Términos y definiciones .................................................................................................... 20
1.5.
Sistema de gestión de la calidad ........................................................................................ 20
1.5.1.
Generalidades ............................................................................................................ 21
1.5.2.
Manual de la calidad ................................................................................................. 22
1.5.3.
Control de documentos.............................................................................................. 22
4
1.6.
Responsabilidad de alta Dirección .................................................................................... 23
1.7.
Gestión de los recursos ...................................................................................................... 26
1.8.
Realización del producto ................................................................................................... 26
1.9.
Medición, análisis y mejora .............................................................................................. 28
CAPÍTULO II ................................................................................................................................... 32
Situación actual ......................................................................................................................... 32
2.
2.1.
Descripción de la empresa................................................................................................. 32
2.2.
Datos de la empresa........................................................................................................... 33
2.3.
Visión ................................................................................................................................ 33
2.4.
Misión ............................................................................................................................... 33
2.5.
Servicios Prestados por LOGICA .................................................................................... 33
2.6.
Clientes Principales de la empresa .................................................................................... 34
2.7.
Situación actual ................................................................................................................. 34
CAPÍTULO III .................................................................................................................................. 36
Análisis del proceso actual y propuesta del modelo de control de documentos.................... 36
3.
3.1.
Control de documentos actual en la empresa .................................................................... 36
3.1.1.
Flujo de proceso actual de Control de Documentos .................................................. 39
3.1.2.
Definiciones y abreviaturas del sistema de gestión de calidad .................................. 39
3.2.
Proceso propuesto para la mejora del control de documentos .......................................... 40
3.2.1
3.3.
Metas y objetivos de la optimización y automatización del proceso ........................ 40
Modelo estándar de control de documentos ..................................................................... 41
3.3.1.
Flujo de control de documentos mejorado ................................................................ 44
CAPÍTULO IV .................................................................................................................................. 47
4.1.
Metodología Rapid Application Development (RAD)...................................................... 47
4.2.
4.2.1.
UML .............................................................................................................................. 49
Diagramas de Casos de uso ....................................................................................... 49
5
4.3.
Análisis de requerimientos de software............................................................................. 56
4.3.1.
Roles .......................................................................................................................... 57
4.3.2.
Especificación de Funcionalidades ........................................................................... 58
4.3.2.1.
Funcionalidades Generales .................................................................................... 58
4.3.2.2.
Funcionalidades Específicas ................................................................................. 58
4.3.2.3.
Funcionalidades para el Representante de la Dirección: ....................................... 58
4.3.2.4.
Funcionalidades para el Coordinador: ................................................................... 60
4.3.2.5.
Funcionalidades para el Responsable: ................................................................... 61
4.3.2.6.
Funcionalidades para el Administrador de Seguridad: .......................................... 61
4.3.3.
4.3.3.1.
4.3.3.2.
Diagramas de caso de uso ......................................................................................... 62
Diagrama de Casos de Uso General ...................................................................... 63
Diagramas de caso de uso a detalle ........................................................................... 64
Los diagramas de caso de uso a detalle se encuentran documentados en el anexo. ...................... 64
4.4.
Especificaciones de Funcionalidades. ............................................................................... 64
4.5.
Especificaciones de Arquitectura. ..................................................................................... 64
4.5.1.
Arquitectura de software ........................................................................................... 64
4.5.2.
Componentes de Interacción ..................................................................................... 67
CAPÍTULO V ................................................................................................................................... 69
DESARROLLO DE LA APLICACIÓN ........................................................................................... 69
5.1.
Lenguaje de programación ................................................................................................ 69
5.2.
Herramientas utilizadas ..................................................................................................... 70
5.2.1.
Power Designer 15.2. ................................................................................................ 70
5.2.2.
Herramienta de desarrollo ......................................................................................... 71
5.2.3.
Motor de base de datos .............................................................................................. 72
5.2.4.
Hibernate ................................................................................................................... 77
5.3.
Fase de Diseño .................................................................................................................. 78
6
5.3.1.
Diagrama BD............................................................................................................. 78
5.3.3.
Diagrama de clases .................................................................................................... 80
5.4.
Desarrollo de prototipo...................................................................................................... 86
5.1.1.
5.2.
Riesgos .................................................................................................................... 101
Fase de construcción ....................................................................................................... 102
5.2.1.
Implementación ....................................................................................................... 102
5.2.2.
Pruebas .................................................................................................................... 103
5.2.3.
Fase de transición .................................................................................................... 105
5.2.3.1.
Seguridades ......................................................................................................... 105
5.2.3.2.
Despliegue ........................................................................................................... 105
5.2.3.3.
Mantenimiento .................................................................................................... 106
CAPÍTULO VI ................................................................................................................................ 107
7.
6.1.
Conclusiones ................................................................................................................... 107
6.2.
Recomendaciones ............................................................................................................ 108
Bibliografía ............................................................................................................................. 109
7.1.
Libros .............................................................................................................................. 110
7.2.
Internet ............................................................................................................................ 110
7
TABLA DE FIGURAS
Figura 1. Modelo de gestión de calidad ....................................................................................... 8
Figura 2. Organigrama estructural de LOGICA ......................................................................... 32
Figura 3. Acceso directo servidor LOGICA .............................................................................. 36
Figura 4. Seguridad de las carpetas en el servidor ..................................................................... 37
Figura 5. Flujo del proceso de control de documentos actual ...................................................... 39
Figura 6. Flujo del proceso de control de documentos mejorado ................................................ 45
Figura 7. Ejemplo de caso de uso ............................................................................................. 53
Figura 8. Ejemplo de modelo entidad relación ........................................................................... 53
Figura 9. Modelo Ejemplo de diagrama de clases ...................................................................... 54
Figura 10. Diagrama general de caso de uso .............................................................................. 63
Figura 11. Capas del sistema .................................................................................................... 65
Figura 12. Diagrama de despliegue ........................................................................................... 67
Figura 13. Modelo entidad relación de la base de datos ........................................................... 79
Figura 14. Diagrama general de paquete ................................................................................... 80
Figura 15. Diagrama de clases del paquete com.integraitec.docbpm.business ............................. 81
Figura 16. Diagrama de clases del paquete com.integraitec.docbpm.models ................................ 82
Figura 17. Diagrama del paquete com.integraitec.docbpm.entity ............................................... 84
Figura 18. Diagrama del paquete com.integraitec.docbpm.visual ................................................ 85
8
INTRODUCCION
En los últimos años las empresas se han enfocado de una manera mucho más responsable a la
calidad de sus productos o servicios, debido a las exigencias cada vez más fuertes de sus clientes, la
gran cantidad de oferta en todos los ámbitos del mercado hacen que el cliente tenga más opciones
de escoger al momento de satisfacer sus necesidades.
Una de las formas más frecuentes de comprobar o avalar la calidad de un bien o servicio son las
certificaciones, las cuales exigen que las empresas cuenten con una serie de requisitos que permiten
un producto final de alta calidad.
Las certificaciones hasta hace poco en el Ecuador eran consideradas como una ventaja competitiva,
sin embargo, en la actualidad las empresas las obtiene para estar a la par de sus competidores.
El mantener una certificación, implica gran manejo de evidencias y documentación las cuales deben
ser gestionadas de manera ordenada y responsable, por lo que la automatización del flujo de
información se vuelve fundamental.
9
ANTECEDENTES
Para cumplir una de las principales exigencias de la norma ISO 9001:2008, la empresa LOGICA se
ha enfocado en realizar un control de documentos estricta y óptimamente,
que le permitirá
continuar el camino hacia la certificación de calidad.
En la actualidad LOGICA trabaja mediante carpetas físicas y manualmente, por lo que no tienen un
control estricto de los documentos. Los cuales corren el riesgo de llegar a extraviarse. El procesar
esta información tarda algunas horas, y no existe el control estricto mediante jerarquía, por lo que se
puede identificar que esta manera de llevar la información no es la más optima ni la más eficiente
en la actualidad.
10
RESUMEN EJECUTIVO
El presente proyecto se basa en la ejecución de una propuesta modelo para control de documentos
de empresa Soluciones Integrales de Compras y Adquisiciones (Lógica), con base en la norma ISO
9001: 2008 y una aplicación automatizada en plataforma de escritorio del modelo propuesto.
El proyecto está enfocado a optimizar el tiempo de la empresa y a reducir el manejo de
documentación física evitando así los errores y manipulación de los documentos, a través de la
eficiencia, agilidad y transparencia del proceso.
Para la ejecución del proyecto se ha realizado un análisis tanto de la Norma ISO 9001 2008 como
de la situación actual de la empresa, logrando así enfocar el proyecto a dar una solución a las
debilidades existentes en control de documentos.
Hemos utilizado el desarrollo rápido de aplicaciones (RAD) que es una metodología de desarrollo
de software, que implica el desarrollo interactivo y la construcción de prototipos, la cual es de
mayor rapidez para el desarrollo.
Para comprobar la viabilidad de este proyecto, se han realizado pruebas en la empresa antes
mencionada las cuales han resultado exitosas de acuerdo a lo planificado, logrando así:
-
Reducción los costos de personal.
-
Reducción en la carga operativa.
-
Asegurar transparencia en el proceso de control de documentos.
11
JUSTIFICACION
La empresa LOGICA con la finalidad de mejorar su gestión y ser más competitiva, actualmente está
en proceso de certificarse en la norma ISO 9001:20081, en tal virtud se ve en la necesidad de
optimizar la forma en la que se realiza el control de documentos. Como parte de su planificación
consta realizar un modelo de control de documentos basado en la norma ISO 9001:2008 para poder
optimizar el tiempo que toma llevar a cabo este proceso.
Este trabajo acortaría el tiempo del proceso en un 80% ya que se podrán realizar los controles
necesarios dentro de la empresa mediante un sistema automatizado realizado en plataforma de
escritorio, con el debido conocimiento de la norma, además de brindar facilidades de uso para los
miembros de LOGICA.
Por otra parte, se ha analizado que existen retrasos en la entrega de informes ya que no poseen la
autorización inmediata. Por consiguiente, mediante el modelo que se propone, se tendrá la
posibilidad de aprobar informes al instante dándole una gran ventaja a la empresa LOGICA en su
acercamiento a la obtención de la certificación en la norma ISO 9001:2008.
1
La ISO 9001 es una norma internacional que se aplica a los sistemas de gestión de calidad (SGC)
y que se centra en todos los elementos de administración de calidad.
12
OBJETIVOS
GENERAL
Desarrollar una propuesta de un modelo para control de documentos basado en la norma
ISO 9001: 2008 e implementar el modelo propuesto en plataforma de escritorio, para la
empresa Soluciones Integrales de Compras y Adquisiciones (Lógica), utilizando software
libre.
ESPECIFICOS
1. Investigar y conocer las exigencias de la Norma ISO 9001: 2008, principalmente
sobre el control de documentos.
2. Analizar la situación actual de la empresa.
3. Analizar el proceso de control de documentos como funciona actualmente en la
empresa LOGICA.
4. Proponer el modelo de control de documentos basados en la Norma ISO 9001: 2008
5. Realizar el diseño conceptual, lógico y físico del proceso de control de
documentación a automatizar.
6. Desarrollar la aplicación.
7. Documentar la aplicación desarrollada.
8. Definir las conclusiones y recomendaciones del proyecto de disertación de tesis.
13
ALCANCE
El presente proyecto de disertación de grado, culminará con la entrega de un documento
que contenga la propuesta del modelo para control de documentos basado en la norma ISO
9001: 2008 y una aplicación automatizada en plataforma de escritorio del modelo
propuesto, aplicado a la empresa Soluciones Integrales de Compras y Adquisiciones
(Lógica).
14
CAPÍTULO I
NORMA ISO 9001:2008
En este capítulo se analizará la norma ISO 9001 2008 por cada uno de sus puntos, los cuales
ayudara al análisis e investigación de cómo proceder a realizar una propuesta de control de
documentos la cual se rija a las exigencias de esta norma, puesto que es indispensable tener
claro el conocimiento de lo que se realizará en el transcurso del desarrollo.
1.1. Introducción
-
Generalidades
La adopción de un sistema de gestión de la calidad debería ser una decisión estratégica de
la organización. El diseño y la implementación del sistema de gestión de la calidad de una
organización están influenciados por:
a) el entorno de la organización, los cambios en ese entorno y los riesgos asociados
con ese entorno,
b) sus necesidades cambiantes,
c) sus objetivos particulares,
d) los productos que proporciona,
e) los procesos que emplea,
f) su tamaño y la estructura de la organización.
No es el propósito de esta Norma Internacional proporcionar uniformidad en la estructura
de los sistemas de gestión de la calidad o en la documentación por lo que cada empresa es
responsable de establecer sus propios formatos para la documentación que maneja. La
norma ISO 9001 2008 establece únicamente los lineamientos generales que se deben
cumplir, y cada organización determina como hacerlo. Los requisitos del sistema de
gestión de la calidad especificados en esta Norma Internacional son complementarios a los
15
requisitos para los productos. La información identificada como "Nota" se presenta a modo
de orientación para la comprensión o clarificación del requisito correspondiente.
Esta Norma Internacional pueden utilizarla partes internas y externas, incluyendo
organismos de certificación, para evaluar la capacidad de la organización para cumplir los
requisitos del cliente, los legales y los reglamentarios aplicables al producto y los propios
de la organización.
En el desarrollo de esta Norma Internacional se han tenido en cuenta los principios de
gestión de la calidad enunciados en las Normas ISO 9000 e ISO 9004.
1.1.2 Enfoque basado en procesos
Esta Norma Internacional promueve la adopción de un enfoque basado en procesos cuando
se desarrolla, implementa y mejora la eficacia de un sistema de gestión de la calidad, para
aumentar la satisfacción del cliente mediante el cumplimiento de sus requisitos.
Para que una organización funcione de manera eficaz, tiene que determinar y gestionar
numerosas actividades relacionadas entre sí. Una actividad o un conjunto de actividades
que utiliza recursos, y que se gestiona con el fin de permitir que los elementos de entrada
se transformen en resultados, se puede considerar como un proceso. Frecuentemente el
resultado de un proceso constituye directamente el elemento de entrada del siguiente
proceso.
La aplicación de un sistema de procesos dentro de la organización, junto con la
identificación e interacciones de estos procesos, así como su gestión para producir el
resultado deseado, puede denominarse como "enfoque basado en procesos".
Una ventaja del enfoque basado en procesos es el control continuo que proporciona sobre
los vínculos entre los procesos individuales dentro del sistema de procesos, así como sobre
su combinación e interacción.
16
Un enfoque de este tipo, cuando se utiliza dentro de un sistema de gestión de la calidad,
enfatiza la importancia de:
a) la comprensión y el cumplimiento de los requisitos,
b) la necesidad de considerar los procesos en términos que aporten valor,
c) la obtención de resultados del desempeño y eficacia del proceso, y
d) la mejora continúa de los procesos con base en mediciones objetivas,
El modelo de un sistema de gestión de la calidad basado en procesos que se muestra en la
Figura 1 ilustra los vínculos entre los procesos presentados en los Capítulos 4 a 8. Esta
figura muestra que los clientes juegan un papel significativo para definir los requisitos
como elementos de entrada. El seguimiento de la satisfacción del cliente requiere la
evaluación de la información relativa a la percepción del cliente acerca de si la
organización ha cumplido sus requisitos. El modelo mostrado en la Figura 1 cubre todos
los requisitos de esta Norma Internacional, pero no refleja los procesos de una forma
detallada.
NOTA De manera adicional, puede aplicarse a todos los procesos la metodología conocida
como "Planificar-Hacer- Verificar-Actuar" (PHVA). PHVA puede describirse brevemente
como:
 Planificar: establecer los objetivos y procesos necesarios para conseguir resultados
de acuerdo con los requisitos del cliente y las políticas de la organización.
 Hacer: implementar los procesos.
 Verificar: realizar el seguimiento y la medición de los procesos y los productos
respecto a las políticas, los objetivos y los requisitos para el producto, e informar
sobre los resultados.
 Actuar: tomar acciones para mejorar continuamente el desempeño de los procesos.
17
Figura 1. Modelo de gestión de calidad
Modelo de un sistema de gestión de la calidad
Descripción basado en procesos
2008
Fecha
ISO 9001:2008 (traducción oficial)
© ISO 2008 – Todos los derechos reservados
Autor/Fuente VII
Titulo
1.1.3 Relación con la Norma ISO 9004
Las Normas ISO 9001 e ISO 9004 son normas de sistema de gestión de la calidad que se
han diseñado para complementarse entre sí, pero también pueden utilizarse de manera
independiente.
La Norma ISO 9001 especifica los requisitos para un sistema de gestión de la calidad que
pueden utilizarse para su aplicación interna por las organizaciones, para certificación o con
fines contractuales. Se centra en la eficacia del sistema de gestión de la calidad para
satisfacer los requisitos del cliente.
18
La edición revisada de la Norma ISO 9004 proporcionará orientación a la dirección, para
que cualquier organización logre el éxito sostenido en un entorno complejo, exigente y en
constante cambio. La Norma ISO 9004 proporciona un enfoque más amplio sobre la
gestión de la calidad que la Norma ISO 9001; trata las necesidades y las expectativas de
todas las partes interesadas y su satisfacción, mediante la mejora sistemática y continua del
desempeño de la organización. Sin embargo, no está prevista para su uso contractual,
reglamentario o en certificación.
1.1.4 Compatibilidad con otros sistemas de gestión
Durante el desarrollo de esta Norma Internacional, se han considerado las disposiciones de
la Norma ISO 14001:2004 para aumentar la compatibilidad de las dos normas en beneficio
de la comunidad de usuarios.
Esta norma internacional no se ve afectada por ningún requisito especifico de otros
sistemas de gestión tales como particulares para la gestiona ambiental, gestión de la
seguridad y salud ocupacional, gestión financiera o gestión de riesgos.
Por consiguiente esta norma permite integrar su propio sistema de gestión de calidad. Es
posible para una organización adaptar su(s) sistema(s) de gestión existente(s) con la
finalidad de establecer un sistema de gestión de la calidad que cumpla con los requisitos de
esta norma.
1.2. Objetivo y campo de aplicación
-
Generalidades
La norma ISO 9001:2008 Es una norma Internacional la cual nos especifica los
requisitos para el sistema de gestión de la calidad tenemos que tener en cuenta que la
empresa tiene que demostrar que puede proporcionar regularmente productos que
19
satisfagan los requisitos del cliente, los legales y reglamentarios aplicables, aspira a
aumentar la satisfacción del cliente a través de la aplicación eficaz del sistema.
-
Aplicación
Los requisitos de la norma son genéricos y se pretende que sea aplicable para todo
tipo de organizaciones. En caso que haya alguna dificultad de cumplir para una
empresa habrá
exclusiones, no se podrá alegar conformidad con esta Norma
Internacional a menos que dichas exclusiones queden restringidas y que estas no
afecten a la capacidad o responsabilidad
de la organización para proporcionar
productos de alta calidad.
1.3. Referencias normativas
Los documentos de referencia son extremadamente importantes, para la aplicación de este
documento es necesaria la fecha actual ya que solo se aplica la edición citada, y para las
que tengan varias fechas se aplicará la última modificación del documento de referencia.
1.4. Términos y definiciones
Para el propósito del documento, serán aplicables los términos dados en la Norma ISO
9000, a lo largo del proceso podemos simplificar la palabra “servicio” por “producto”
1.5. Sistema de gestión de la calidad
-
Requisitos generales
La organización tendrá que establecer, documentar, implementar y mantener un
sistema de gestión de la calidad y aplicar la mejora continua en su organización de
acuerdo con los requisitos de esta norma internacional.
Requerimientos a cumplir por parte de las organizaciones para certificarse:
20

Se deben definir los procesos necesarios que se desempeñan en la empresa
para el sistema de gestión de la calidad y su aplicación la cual estará
documentada.

Es indispensable determinar la secuencia y la interacción entre sí de todos
los procesos.

Asegurar que todos los procesos sean eficaces por medio de criterios y
métodos necesarios para que éstos se cumplan con la finalidad de tener una
buena organización

Tener en cuenta siempre la disponibilidad de los recursos e información
necesaria para apoyar a la operación

Dar seguimiento continuo, a través de evaluación y medición, para
mantener una mejora continua

Implementar acciones en la organización para poder alcanzar la mejora
continua.
En el supuesto que la organización desee contratar externamente la ejecución de
cualquier proceso que afecte a la gestión de calidad, la organización debe asegurar
controlar esos procesos y esos controles deberán estar definidos dentro del sistema de
gestión de la calidad y no exime a la organización de la responsabilidad de cumplir
con todos los requisitos del cliente, legales y reglamentarios.
-
Requisitos de la documentación
1.5.1.
Generalidades
Requisitos de la documentación exigidos:

Declaraciones documentales de una política de la calidad.
21

Manual de la calidad.

Los procedimientos de la organización debidamente documentados.

Registros requeridos por la Norma.
Que quiere decir con el término “procedimiento documentado” dentro de la
Norma Internacional significará que el procedimiento debe estar establecido,
documentado, implementado y mantenido. Un solo documento podrá incluir los
registros para uno o más procedimientos.
La documentación es muy importante y deberá existir en la organización a
disposición de todos en cualquier formato o tipo de medio ya que es esencial
para poder ser certificados.
1.5.2.
Manual de la calidad
En el manual de la calidad se debe incluir el alcance del sistema de gestión de
la calidad detallado y justificado, los procedimientos o en su vez una referencia
donde está el documento del procedimiento y una descripción de la interacción
entre los procesos.
1.5.3.
Control de documentos
Los documentos requeridos por el sistema de control de calidad deben
controlarse cuidadosamente ya que estos documentos deben estar de acuerdo
con los requisitos establecidos para proporcionar la evidencia de la
conformidad. La organización debe tener su procedimiento documentado en
cualquier formato para poder definir los controles necesarios como
almacenamiento, protección, la recuperación y la retención de los registros,
22
luego de esto deberá la organización tener en cuenta cómo va a manejar la
disposición de los registros la cual deberá estar documentada.
Los documentos de origen externos que la organización decida que son
necesarios e indispensables para la planificación y la operación del sistema de
gestión de la calidad, se identificarán y controlarán su distribución. Por ejemplo,
la documentación que envía cada cliente a la empresa. Por último, se debe
prevenir el uso no intencionado de documentos obsoletos y aplicarles una
identificación según las versiones del mismo, estos documentos podrán estar
guardados en cualquier formato o físicamente.
1.6. Responsabilidad de alta Dirección
-
Compromiso de alta Dirección
Está por demás decir que el compromiso y la responsabilidad de la Alta dirección son
vitales en el desarrollo e implementación del sistema de gestión de calidad, debe
promover la mejora continua en la organización.
La Alta dirección se encargara de los siguientes puntos:

Comunicar a los integrantes de la organización lo importante de satisfacer
tanto los requisitos del cliente como los legales y reglamentarios.

Establecer la política de calidad y hacer conocer a todos los integrantes de la
organización.

Crear los objetivos de la calidad correctamente para la organización llevando
a cabo las revisiones por la dirección, y asegurando la disponibilidad de
recursos.
23
-
Enfoque al cliente
La Alta dirección tendrá que satisfacer las necesidades del cliente brindándole una
mejora continua en los productos con el propósito de aumentar la satisfacción el
cliente.
-
Política de la calidad
La Alta dirección se encargará de la política de calidad, revisando que sea adecuada a
la organización e incluirán un compromiso para cumplir con los requisitos y cada día
ir mejorando continuamente la eficacia del sistema de gestión de la calidad, también
la alta dirección tendrá que revisar los procedimientos de la política de la calidad
establecidos.
-
Planificación
Todos los objetivos de la calidad deben ser revisados por la alta dirección, se
establecen cargos y funciones a los respectivos miembros de la organización y estos
deben ser medibles y coherentes con la política de calidad.
La Alta dirección también debe encargarse de la planificación del sistema de gestión
de la calidad para lo cual debe asegurarse de que cumpla con los requisitos y los
objetivos de la calidad, y deben mantener la integridad del sistema de gestión de
calidad cuando se planifique e implemente cambios.
-
Responsabilidad autoridad y comunicación
La Alta dirección debe asegurarse de que todas las responsabilidades y autoridades
estén definidas y toda la organización esté informada.
24
Los representantes de la dirección serán designados por la Alta dirección la cual
deberá seleccionar a un representante que tenga autoridad y responsabilidades
principales éstas serán:
a) Asegurarse de que se establecen, implementan y mantienen los procesos necesarios
para el sistema de gestión de la calidad.
b) Informar a la Alta dirección como está progresando el sistema de gestión de calidad
y hacer saber si se necesita de alguna mejora.
c) Asegurarse de que se tomen en cuenta los requisitos en todos los niveles de la
organización.
La Alta dirección debe tomar en cuenta que se deben establecer procesos de
comunicación apropiados dentro de la organización. La comunicación se considera la
eficacia del sistema de gestión de calidad.
-
Revisión por la Alta Dirección
El sistema de gestión de la calidad de la organización debe ser revisado por la Alta
dirección, esta revisión debe incluir una evaluación de oportunidades de mejora y la
necesidad de efectuar cambios en el sistema de gestión de calidad.
La información de entrada para la revisión debe incluir, los resultados de auditorías la
retroalimentación del cliente, el desempeño de los procesos, el estado de las acciones
correctivas, las acciones de seguimiento, los cambios que podrían afectar al sistema y
las recomendaciones para la mejora.
Los resultados de la revisión están relacionados con la mejora de la eficacia del
sistema de gestión de la calidad y sus procesos, la mejora del producto en relación con
los requisitos del cliente y las necesidades de recursos.
25
1.7. Gestión de los recursos
-
Provisión de recursos
La organización debe determinar y proporcionar todos los recursos necesarios para la
implementación, mantenimiento del sistema de gestión de la calidad y para aumentar
la satisfacción del cliente mediante el cumplimiento de sus requisitos.
-
Recursos humanos
El personal que esté involucrado en la conformidad con los requisitos del producto
debe ser competente con base a la educación, formaciones, habilidades y experiencias
apropiadas.
La organización debe determinar cuando sea aplicable, proporcionar formación o
tomar otras acciones para lograr la competencia necesaria, evaluar la eficacia de las
acciones tomadas y asegurar que su personal sea consciente de la pertinencia.
-
Infraestructura
La empresa debe determinar proporcionar y mantener en buen estado la
infraestructura, en la infraestructura estamos hablando de lugar de trabajo y accesorios
necesarios para poder realizar el servicio o producto adecuadamente.
-
Ambiente de trabajo
El ambiente de trabajo es uno de los factores que la empresa debe tomar en cuenta ya
que esto podría afectar al desenvolvimiento del personal ya que incluye desde la
temperatura en la cual se trabaja hasta el ruido, por lo que la Alta gerencia debe tomar
en cuenta.
1.8. Realización del producto
-
Planificación de la realización del producto
26
La organización debe planificar como el producto o servicio se va a llevar a cabo para
lo cual es indispensable desarrollar los procesos necesarios para la realización del
producto durante la planificación se debe: tomar en cuenta los objetivos de la calidad,
requisitos del producto, las actividades requeridas como verificación validación
seguimiento, inspección, ensayo, pruebas al final se ve que el producto cumpla con
todos los requisitos predeterminados y que haya seguido el respectivo proceso. El
resultado de esta planificación debe presentarse de forma adecuada para la
metodología de operación de la organización.
-
Procesos relacionados con el cliente
Cuando los procesos son relacionados con el cliente lo que la organización tiene que
hacer es revisar los requisitos relacionados con el producto, mantener una integra
comunicación con el cliente, tener en cuenta los requisitos legales y reglamentarios
aplicables al producto.
La revisión de los requisitos relacionados con el producto deberán ser revisados por la
Alta gerencia antes de que la organización se comprometa a proporcionar el producto
al cliente. Si por alguna circunstancia los requisitos no están del todo claros la
organización deberá comunicarse con el cliente y asegurarse que todos los datos
necesarios para la elaboración del producto estén en orden.
-
Diseño y desarrollo
La organización deberá planificar el diseño y desarrollo del producto la cual tendrá
algunas etapas entre ellas las más importantes revisión, validación, y control de los
cambios necesarios ya que estos deben ser revisados minuciosamente antes de que se
cambie.
27
-
Compras
La organización deberá asegurarse que el producto cumple con las expectativas del
cliente para lo cual se debe tener en cuenta la información de las compras, y la
verificación de los productos comprados.
-
Producción y prestación del servicio
La organización en este punto tiene que tener bien planificado y llevar a cabo la
producción del servicio bajo las condiciones controladas, con el uso del equipo
apropiado. La validación de los procesos de la producción y de la prestación del
servicio estará controlada por la organización si los resultantes no se pueden verificar
mediante seguimiento o mediciones posteriores, la validación deberá demostrar la
capacidad de estos procesos para alcanzar los resultados planificados.
-
Control de los equipos de seguimiento y medición
El control de los equipos de seguimiento y de medición deberá proporcionar la
evidencia necesaria de la conformidad del producto con los requisitos determinados.
La organización debe establecer procesos los cuales puedan realizarse de una manera
coherente, éstos deberán ajustarse, revisarse, protegerse constantemente, y si existe
algún cambio deberá enterarse la Alta gerencia antes de cualquier cambio o problema
del mismo.
La confirmación de la capacidad del software para satisfacer su aplicación prevista
incluiría habitualmente su verificación y gestión de la configuración para mantener la
idoneidad para su uso.
1.9. Medición, análisis y mejora
-
Generalidades
28
Es deber de la organización implementar los procesos de medición, análisis y mejora
de los procesos, para que así se demuestre la conformidad de los requisitos del
producto, asegurarse de la conformidad del sistema y mejorar continuamente la
eficacia del sistema de control de calidad.
-
Seguimiento y medición
En el seguimiento y medición, la organización se debe enfocar en la satisfacción del
cliente, lo cual debe haber comunicación directa para tomar en cuenta como se está
llevando a cabo el sistema de gestión de calidad por lo cual deben determinarse los
métodos para obtener y utilizar dicha información.
La auditoría interna también está involucrada, mediante ésta, se deberá determina si el
sistema de gestión de calidad es conforme con las disposiciones planificadas y si se ha
implementado de manera eficaz.
Para esto, la organización debe planificar un programa de auditorías tomando en
cuenta el estado, la importancia de los procesos y se debe establecer un procedimiento
documentado para definir las responsabilidades y los requisitos para planificar las
auditorías, establecer los registros e informar de los resultados.
La Alta gerencia deberá aplicar los métodos apropiados para el seguimiento y
medición de los procesos y productos, determinando cuando no se alcancen los
resultados planificados, deben llevarse a cabo correcciones y acciones correctivas,
según sea conveniente.
-
Control del producto no conforme.
29
Si el producto fue considerado como no conforme, la organización debe asegurarse
que la información entregada esté correctamente y se deberá establecer un
procedimiento documentado para definir los controles, las responsabilidades y
autoridades relacionadas para tratar el producto no conforme. Además, la
organización debe tomar medidas tales como: tomar acciones para eliminar la no
conformidad encontrada en el producto, impedir su uso y posteriormente cuando se
corrige un producto no conforme, debe someterse a una nueva verificación para
demostrar su conformidad con los requisitos.
-
Análisis de datos
El análisis de datos está basado en determinar, recopilar y analizar los datos
apropiados para poder demostrar la idoneidad y la eficacia del sistema de gestión de
calidad y así poder identificar donde se pueden hacer los cambios para la mejora
continua del sistema. El análisis de datos se enfoca en la satisfacción del cliente, la
conformidad de los requisitos de los productos, las características de los procesos e
incluir las oportunidades para llevar a cabo las acciones preventivas.
-
Mejora
La organización debe tomar acciones para eliminar las no conformidades con el
propósito de que no vuelvan a ocurrir por lo que las acciones correctivas deben ser las
apropiadas. Para lo cual se debe revisar las no conformidades, determinar las causas
de las no conformidades y evaluar la necesidad de adoptar acciones para asegurarse
de que no vuelvan a ocurrir. Finalmente deberán revisar la eficacia de las acciones
correctivas tomadas.
30
La organización debe tomar acciones preventivas para poder eliminar las principales
causas de no conformidades por lo cual se elaborará un procedimiento el cual
determinarán las principales no conformidades y causas, evaluar la necesidad de
actuar para prevenir la ocurrencia, determinar las acciones necesarias, registrar los
resultados de las acciones tomadas y revisar la eficacia de las acciones preventivas.
31
CAPÍTULO II
INFORMACIÓN DE LA EMPRESA SOLUCIONES INTEGRALES DE COMPRAS Y
ADQUISICIONES (LÓGICA)
2. Situación actual
En el presente capítulo se analizará a fondo el estado actual de la empresa, para así adaptar un
sistema el cual permita el fácil acceso y manejo de control de documentos. Se analizara el
ámbito laboral de la empresa y como actualmente están llevando a cabo el tema de control de
documentos de esta manera se tendrá una visualización clara de cómo se procederá a realizar la
propuesta del modelo de control de documentos adaptados a la ISO 9001:2008.
2.1. Descripción de la empresa
Lógica es una empresa formada por profesionales en las áreas de compras, planificación,
tributación e inventarios, que responde a la necesidad de las empresas de mejorar sus
procedimientos de negociación y costes de adquisición.
La estructura organizacional de la empresa, se muestra a continuación:
Gerente General
Gerente de
Ventas
Gerente de
Operaciones
Supervisor de
Calificación
Asistente 1
Asistente 2
Asistente 3
32
Titulo
Descripción
Fecha
Autor/Fuente
Figura 2
Organigrama estructural de LOGICA
18/10/2012
Plan estratégico de la empresa
2.2. Datos de la empresa
2.2.1. Datos generales de la empresa
Nombre: Soluciones Integrales de Compras y Adquisiciones PROCUREGMG Cia.
Ltda. (LOGICA)
Actividad: La empresa proporciona soluciones integrales en la gestión de compras,
calificación de proveedores y toma física de inventarios, optimizando los recursos
en cada una de las áreas de sus clientes y volviéndolas más ágiles.
Ubicación: Avenida Orellana E9-195 y Av. 6 de Diciembre Edificio ALISAL de
Orellana, piso 6, oficina 603. Quito, Pichincha-Ecuador
Características: Expertos en las áreas de COMPRAS, PLANIFICACIÓN,
TRIBUTACIÓN e INVENTARIOS.
2.3. Visión
Ser reconocidos en el Ecuador y los países andinos como una organización líder
que aporta a los procesos operativos y de soporte de sus clientes.
2.4. Misión
Somos una organización multinacional, innovadora y flexible, orientada a mejorar
la eficiencia de los procesos operativos y de soporte de nuestros clientes a través de
un servicio de calidad sustentado en un equipo multidisciplinario que les permita
mantener el enfoque en la actividad principal de su negocio.
2.5. Servicios Prestados por LOGICA
A continuación detallamos los servicios que son brindados por la empresa:
33

Calificación de Proveedores

Levantamiento de Bases de Proveedores

Administración de procesos de licitación

Negociación de Contratos

Administración parcial o completa de procesos de compra
2.6. Clientes Principales de la empresa
LOGICA, actualmente trabaja con los siguientes clientes principales:
-
CITIBANK
-
Nokia Siemens
-
Lafarge
-
Mutualista Pichincha
-
Fybeca
-
Cooperativa Cooprogreso
-
Quiport
2.7. Situación actual
La empresa LOGICA actualmente se encuentra tratando de implementar el
Sistema de Gestión de la Calidad ISO 9001:2008, el personal de la empresa ha
sido capacitado para realizar la implementación y el cumplimiento de las
exigencias y los estándares necesarios para obtener la certificación en Gestión de
la Calidad.
Como parte de esta implementación, se ha realizado cambios en el último año en
políticas y en documentación de la empresa, así como también la formalización de
los procesos que gobiernan la operatividad de la organización. Este cambio ha
llevado a la empresa a realizar y llevar un control sobre los documentos y registros
de acuerdo a lo estipulado por la ISO.
34
La gestión de documentos actualmente se realiza de manera “ad-hoc” y manual,
además cabe mencionar que si bien la empresa ha tratado de hacer uso de recursos
tecnológicos para efectuar este control mediante el uso de carpetas compartidas
sobre un servidor en red Windows, ésto podría conllevar a riesgos de seguridad o
integridad en los datos manejados.
35
CAPÍTULO III
PROPUESTA DEL MODELO DE CONTROL DE DOCUMENTOS
3.
Análisis del proceso actual y propuesta del modelo de control de documentos
Este capítulo trata del análisis a fondo del proceso actual de control de documentos que está
llevando a cabo la empresa, sus fortalezas y debilidades, las cuales se tomaron en cuenta para
realizar la propuesta que se encuentra a continuación con las respectivas observaciones para el
adecuado manejo de los documentos en la empresa. Presenta también los flujos respectivos del
proceso actual de la empresa y el flujo del proceso propuesto.
3.1. Control de documentos actual en la empresa
La empresa actualmente está implementando la norma ISO: 9001:2008, por lo cual
necesita cumplir una serie de requerimientos, entre los cuales está el control de
documentos cláusula 1.5.3.
En la actualidad la gestión documental en la empresa es manual, a continuación se detalla
la manera en la que se efectúa dicho control:
-
La institución dispone de un servidor con capacidad de 1 TB en disco duro, que está
ubicado en las instalaciones de la empresa.
Las computadoras están conectadas
mediante una red LAN.
-
Los usuarios tienen en su equipo una conexión a la red del servidor tal y como se
muestra en la figura 3.
Titulo
Figura 3
36
Acceso directo servidor
Descripción LOGICA
18/10/2012
Fecha
Autor/Fuente Servidor compartido Lógica
-
Los documentos actualmente se encuentran alojados en carpetas en el servidor, las
cuales están compartidas para los diferentes miembros del equipo de trabajo. Cada
carpeta de trabajo en el servidor se encuentra con permisos abiertos para todo el
personal.
Titulo
Descripción
Fecha
Autor/Fuente
-
Figura 4
Seguridad de las carpetas en el servidor
18/10/2012
Servidor compartido Lógica
Si existe un nuevo miembro del equipo y necesita acceso a los documentos se
comunica directamente con el Gerente General el cual procederá a dar los permisos de
ser prudente.
37
El objetivo del control de documentos es asegurar que los documentos utilizados en el SGC
se encuentren vigentes y controlados, tendrán que ser aprobados por el responsable que en
este caso es el Gerente General. El alcance al cual la empresa tendrá llegar es que todos los
documentos actuales estén involucrados en el sistema de gestión de la calidad.
Por lo que después de un análisis minucioso hemos llegado a la conclusión que LOGICA no
dispone de un control de documentos seguro puesto que cualquier persona puede realizar
cambios sin pedir permiso, o borrar dicho documento esto es una falencia la cual podría
perjudicar en la obtención de la norma ISO 9001:2008, el único control que tiene lógica es
que al documento final lo revisa el Gerente General de la empresa.
LOGICA consta de los siguientes procedimientos los cuales no están debidamente
controlados:
-
Almacenamiento de procedimientos: Los procedimientos de LOGICA son
actualmente almacenados en una carpeta en el servidor, la cual no tiene ninguna
seguridad extra para mantener esa información intacta.
-
Relación entre documentos y procedimientos: Actualmente LOGICA no consta de
una relación directa entre procedimiento y documento.
-
Control de cambios: LOGICA no mantiene un control de cambios de los documentos
de la empresa, ya que las personas encargadas pueden acceder a la red y cambiar el
documento que requieran. No existe seguridad alguna para este tipo de cambios
simplemente la confianza en el personal de trabajo. Debido a esto los certificadores de
la norma ISO 9001:2008 podrían levantar una no conformidad mayor, lo cual
impediría que la empresa sea certificada.
38
-
Aprobación de documentos: LOGICA consta solamente con una aprobación final
por parte de la Gerente General la cual revisa cuando el documento está listo para ser
firmado.
3.1.1.
Flujo de proceso actual de Control de Documentos
A continuación, mostramos un diagrama del proceso actual de la empresa con
relación al control de documentos:
Titulo
Descripción
Fecha
Autor/Fuente
Figura 5
Flujo del proceso de control de documentos actual
18/10/2012
Gustavo Justicia, Lucia Del Pino
3.1.2.
Definiciones y abreviaturas del sistema de gestión de calidad
SGC:
Sistema de Gestión de Calidad.
NA:
No aplica.
39
Documento:
Detalle de información referente a un tema en particular puede ser Manual,
Procedimiento, Proceso, Instructivo, Política de la Calidad, Objetivos de la Calidad,
Organigrama, Presentación de la empresa y Matriz de Objetivos.
LMD: Lista Maestra de Documentos.
LMR: Lista Maestra de Registros.
3.2. Proceso propuesto para la mejora del control de documentos
Después de analizar la situación actual de la empresa LOGICA y del proceso de control de
documentos, proponemos una mejora de proceso previo la implementación de un sistema
de control de documentos personalizado que permita suministrar la información, oportuna,
confiable, actualizada, y relevante a los procesos que realiza tanto como ventas, informes,
contratos, inventarios, servicios, etc., teniendo la posibilidad de toma de decisiones en
todos los noveles organizacionales siendo la información compatible con los procesos y
controles establecidos por la institución.
3.2.1 Metas y objetivos de la optimización y automatización del proceso
Objetivo general
 Realizar la automatización del modelo propuesto del sistema de control de
documentos.
Objetivos específicos
 Mejorar la calidad del control de documentos.
 Aumentar la rapidez, minimizar el esfuerzo de producción
 Aumentar la productividad reduciendo tiempo en elaboración
 Reducir la intervención humana
 Aumentar la seguridad de la información en la empresa
40
3.3.
Modelo estándar de control de documentos
Se necesita de una solución que permita la automatización, de forma segura y
eficiente, de todos los procesos actuales que se practican en las transacciones diarias
del negocio.
La siguiente documentación consistirá en el procedimiento,
el cual ha sido
elaborado en base a los lineamentos de la Norma ISO 9001:2008 y los
conocimientos adquiridos con la empresa consultora (KONEGGUI).
KONEGGUI es una empresa consultora la cual se encarga de implementación y
seguimientos de sistemas de gestión de calidad.
RESPONSABLE
ACTIVIDAD
DESCRIPCION DE LA ACTIVIDAD
DE LA ACTIVIDAD
 Aprobación de
 Persona
DE LOS DOCUMENTOS
los Documentos
responsable del
Un documento se considera como aprobado
documento.
cuando el encargado de calidad ha aprobado
un dado click en la aprobación, el sistema
automáticamente actualiza la lista maestra de
documentos (LMD). Estos documentos solo
pueden ser abiertos
únicamente por las
personas que les han designado permisos.
DE LOS FORMATOS Y LISTAS: Cada vez
que
se
requiera
realizar
un
cambio
significativo a este tipo de documentos los
responsables se comunican por medio de la
41
herramienta de control del cambios
El Representante de la Dirección realiza los
cambios
solicitados,
cambiará
automáticamente la fecha de la revisión, y
actualizará en los lugares pertinentes.
 Revisión y
 Cada vez que se requiera realizar un  Persona
Actualización de
cambio significativo a un documento, los
responsable del
los Documentos.
responsables mandan una notificación
documento.
mediante el módulo de gestión de
cambios al Representante de la Dirección
y se procede a ejecutar lo indicado para la
aprobación del cambio
 Identificación de
 Una vez que se ha realizado el cambio en  Persona
cambios y
el documento, éstos quedan identificados
responsable del
estado de
utilizando la manera secuencial y de
documento.
versión actual de
forma ascendente el nivel de versión que
los Documentos
corresponda, además se debe llenar el
detalle
del
historial
de
control
de
revisiones. Quedará registrado solo el
cambio de las últimas tres versiones
realizadas.
42
 El control de cambios solo aplica para
procesos, procedimientos, manuales e
instructivos. Para los demás documentos
se incrementa la revisión.
 Versiones
 Una vez realizado los cambios se subirá el  Persona
pertinentes de
documento la herramienta de control de
responsable del
los Documentos
documentos para ser aprobado, estos
documento.
documentos estarán disponibles para las
personas autorizadas en los puntos de
uso el cual será en la LMD.
 Documentos
 Todos los documentos son legibles e  Persona
permanecen
identificables por su nombre, fecha de
responsable del
legibles y
creación, revisión y aprobación.
documento.
fácilmente
identificables
 Protección de
los documentos
 Se contará con una base de datos que será  Representante de
administrada por el Representante de la
la Dirección
Dirección, el cual será encargado de dar
los respectivos permisos. Dicha base de
datos se encuentra centralizada en un
servidor con acceso protegido por usuario
y contraseña.
43
 Documentos de
 El Representante de la Dirección es el  Persona
origen externo
responsable de definir los documentos
responsable del
externos y subirlos al programa que
documento.
requieren ser incluidos en la LMD, y que
son
utilizados
en
sus
actividades
cotidianas y de asegurar que se mantiene
la versión actualizada del documento.
 Documentos
 No se mantienen documentos obsoletos.  Persona
Obsoletos
Titulo
Descripción
Fecha
Autor/Fuente
Solo se consideran documentos vigentes
responsable del
aquellos identificados en la LMD.
documento.
Tabla 1.1 Descripción del procedimiento
propuesto
Tabla del procedimiento propuesto.
18/10/2012
Gustavo Justicia, Lucia Del Pino
3.3.1. Flujo de control de documentos mejorado
44
Titulo
Descripción
Fecha
Autor/Fuente
Figura 6
Flujo del proceso de control de documentos mejorado
18/10/2012
Gustavo Justicia, Lucia Del Pino
A continuación se detalla un cuadro en el cual se explica la situación actual de la empresa y
como se propone realizar el modelo de control de documentos de acuerdo al flujo de
proceso mejorado mencionado anteriormente:
Control de
documentos basado
en la ISO 9001:2008
Revisión y
1 actualización de
documentos
Situación actual
Proceso mejorado
El encargado de delegar la creación puede seleccionar la
Solo el gerente de la empresa revisa y
persona que revisara o actualizara dicho documento para
actualiza el documento
posteriormente ser aprobado por el gerente de la empresa
45
2
Aprobación de
documentos
Identificación de
cambios y estado de
3
versión actual de
documentos
4
Confidencialidad de
los datos
Solo el documento final es aprobado
por el gerente de la empresa
El programa exige que exista una revisión antes de la
aprobación del documento
Las versiones se manejan por la
ultima fecha de modificación
El programa limita las versiones de un documento, se graba
automáticamente en la base con el numero de versión
correspondiente, los documentos no pueden ser modificados
luego de su aprobación, en caso de ser modificados se crea
automáticamente otra versión detallando el cambio en la
descripción del documento, por seguridad se almacena las 3
ultimas versiones del documento, en la base.
Todos los integrantes de la empresa
tienen acceso a modificar y leer la
información
El programa permite la creación de grupos y perfiles con
usuario y contraseña tanto para la lectura como la
modificación de documentos
Seguridad de la
5
información
Los documentos se almacenan en una base de datos, los
Los datos se encuentran en un
usuarios solo podrán acceder a ciertos documentos de
servidor en una carpeta compartida, y
acuerdo a su perfil por medio de usuario y contraseña, mas
no existe seguridad de la información
no externamente
6 Procesos del negocio
Los procesos de la empresa se
encuentra en documentos en la
carpeta general
Los procesos se almacenan en una tabla de procesos lo
cuales podrán ligarse a los documentos que se realicen en el
transcurso del tiempo
Los documentos obsoletos se graban
en la red o son borrados a discreción
de usuario
El programa guarda únicamente las 3 últimas versiones las
de mas se borran automáticamente muestras se vaya
creando una versión más.
Documentos obsoleto
7
Tabla 1.2 Situación actual VS proceso mejorado
Propuesta de control de documentos mejorado vs la
Descripción situación actual de la empresa.
18/10/2012
Fecha
Autor/Fuente Gustavo Justicia, Lucia Del Pino
Titulo
46
CAPÍTULO IV
DISEÑO LÓGICO CONCEPTUAL DEL PROCESO A AUTOMATIZAR
Se presenta el diseño de la aplicación y sus respectivos diagramas comenzado con una breve
explicación de la metodología utilizada, el análisis de requerimientos de software la cual es
muy importante puesto que mediante esta información se realizara los respectivos controles de
la seguridad de la información teniendo en cuenta los roles que nombra en la ISO 9001:2008,
para un mejor entendimiento se realizó los diagramas de caso de uso los que ayudaran a un
mejor entendimiento de las relaciones del desarrollo con el usuario, terminando con las
especificaciones de la arquitectura y los componentes de interacción.
4.1. Metodología Rapid Application Development (RAD)
El desarrollo rápido de aplicaciones (RAD) es una metodología de desarrollo de
software, que implica el desarrollo iterativo y la construcción de prototipos. El
desarrollo rápido de aplicaciones es un término originalmente utilizado para describir
un proceso de desarrollo de software introducido por James Martin en 1991.
Entre sus Principios básicos:
-
Rápido desarrollo y entrega de una alta calidad en un sistema de relativamente bajo
costo de inversión.
-
Reducción de riesgos inherentes del proyecto debido a segmentación del proyecto
-
Se enfoca en los requerimientos del cliente y la manera de plasmarlos en el sistema,
mas que en la ingeniería tecnológica
47
-
En general incluye Joint application development (JAD), donde los usuarios están
intensamente participando en el diseño del sistema, ya sea a través de la creación de
consenso estructurado en talleres, o por vía electrónica.
-
La participación activa de los usuarios es imprescindible.
-
Produce la documentación necesaria para facilitar el futuro desarrollo y
mantenimiento.
Esta metodología tiene un ciclo de vida corto y está basado mayormente en el
desarrollo de prototipos mediante reuniones constantes con el cliente final. Esta
metodología está divida en cuatro fases:

Fase de planificación de requerimientos – Combina los elementos de análisis
y planificación de sistemas del ciclo de vida del desarrollo de software general;
Aquí los usuarios finales, gerentes y los miembros del equipo de desarrollo
discuten y acuerdan las necesidades del negocio, el alcance del proyecto, las
limitantes y los requerimientos del sistema. Esta fase acaba cuando el equipo
se pone de acuerdo en los problemas clave y obtiene la autorización de
continuar con el siguiente paso.

Fase de diseño de usuario – En esta fase los usuarios interactúan con los
analistas del sistema y desarrollan los modelos y prototipos que representarán
todos los procesos del sistema sus entradas y salidas. La fase de diseño de
usuario es un proceso continuo interactivo que permite a los usuarios modificar
e incluso eventualmente aprobar un modelo funcional del sistema que cumpla
sus necesidades.

Fase de construcción – Se enfoca en el desarrollo de la aplicación de forma
similar que en el ciclo de vida del software, sin embargo en esta metodología el
usuario continúa participando y aún puede sugerir cambios o mejoras “sobre la
marcha”.
48

Fase de transición – En esta se junta las tareas finales en una implementación
del ciclo de vida del software incluyendo la conversión de datos cambios al
nuevo sistema y la capacitación a los usuarios. De esta forma el sistema esta
puesto en producción de una manera mucho más rápida.
4.2. UML
UML o Lenguaje de Modelado Unificado, es el lenguaje de modelado mas
utilizado a nivel mundial para al definición de diagramas y modelos enfocados al
desarrollo de software, es un lenguaje sumamente útil para la representación de
procesos y los diferentes componentes que existen y conviven dentro de un
sistema de información.
Los diagramas UML pueden ser considerados de importancia vital al momento de
apoyarse en una metodología de desarrollo de software, debido a su organización,
trazabilidad de procesos y actividades que realiza un sistema desarrollado lo cual
permite un alto grado de calidad y mantenibilidad del software.
4.2.1. Diagramas de Casos de uso
Los diagramas de casos de uso describen las relaciones y las dependencias entre un
grupo de casos de uso y los actores participantes en el proceso.
Es importante resaltar que los diagramas de casos de uso no están pensados para
representar el diseño y no puede describir los elementos internos de un sistema. Los
diagramas de casos de uso sirven para facilitar la comunicación con los futuros
usuarios del sistema, y con el cliente, y resultan especialmente útiles para determinar
las características necesarias que tendrá el sistema. En otras palabras, los diagramas de
casos de uso describen qué es lo que debe hacer el sistema, pero no cómo.
49
F.1 Ingreso al Sistema
Coordinador/Representante
de la Dirección
Titulo
Descripción
Fecha
Autor/Fuente
Responsable
Figura 7
Ejemplo de caso de uso
18/10/2012
Gustavo Justicia, Lucia Del Pino
Los casos de uso son descriptores de las interacciones típicas entre los usuarios de
un sistema y ese mismo sistema. Representan el interfaz externo del sistema y
especifican qué requisitos de funcionamiento debe tener este cuando se trabaja con
casos de uso, es importante tener presentes algunas sencillas reglas:
-
Cada caso de uso está relacionado como mínimo con un actor
-
Cada caso de uso lleva a un resultado relevante (un resultado
con «valor intrínseco»)
Los casos de uso pueden tener relaciones con otros casos de uso. Los tres tipos de
relaciones más comunes entre casos de uso son:
-
<<include>> que especifica una situación en la que un caso de
uso tiene lugar dentro de otro caso de uso
-
<<extends>> que especifica que en ciertas situaciones, o en
algún punto (llamado punto de extensión) un caso de uso será
extendido por otro.
-
Generalización que especifica que un caso de uso hereda las
características del «super» caso de uso, y puede volver a
especificar algunas o todas ellas de una forma muy similar a las
herencias entre clases.
50
Actor
Un actor es una entidad externa (de fuera del sistema) que interacciona con el
sistema participando (y normalmente iniciando) en un caso de uso. Los actores
pueden ser gente real (por ejemplo, usuarios del sistema), otros ordenadores o
eventos externos.
Los actores no representan a personas físicas o a sistemas, sino su rol. Esto significa
que cuando una persona interactúa con el sistema de diferentes maneras (asumiendo
diferentes papeles), estará representado por varios actores. Por ejemplo, una persona
que proporciona servicios de atención telefónica a clientes y realiza pedidos para
los clientes estaría representada por un actor «equipo de soporte» y por otro actor
«representante de ventas».
Descripción de casos de uso
Las descripciones de casos de uso son reseñas textuales del caso de uso.
Normalmente tienen el formato de una nota o un documento relacionado de alguna
manera con el caso de uso, y explica los procesos o actividades que tienen lugar en
el caso de uso. 2
4.2.2. Modelo E-R
Diagrama Entidad Relación: Denominado por sus siglas como: E-R. Este modelo
representa a la realidad a través de un Esquema gráfico empleando los terminología
de Entidades, que son objetos que existen y son los elementos principales que se
identifican en el problema a resolver con el diagramado y se distinguen de otros por
sus características particulares denominadas Atributos, el enlace que rige la unión
de las entidades está representada por la relación del modelo.
2
http://docs.kde.org/stable/es/kdesdk/umbrello/uml-elements.html
51
Titulo
Descripción
Fecha
Autor/Fuente
Figura 8
Ejemplo de modelo entidad relación
18/10/2012
Gustavo Justicia, Lucia Del Pino
En un diagrama entidad relación, cada entidad se representa mediante un rectángulo, cada
relación mediante un rombo y cada dominio (conjunto donde toma valores el atributo)
mediante un círculo. Mediante líneas se conectan las entidades con las relaciones, igual que
las entidades con los dominios, representando a los atributos. Los Atributos Llaves se
representan subrayando el correspondiente conjunto de valores.
En ocasiones, una entidad no puede ser identificada únicamente por el valor de sus propios
atributos. En estos casos, se utilizan conjuntamente las relaciones con los atributos para
lograr la requerida identificación unívoca. Estas entidades reciben el nombre de entidades
débiles y se representan en el DER con un doble rectángulo. El MER restringe las
relaciones a usar para identificar las entidades débiles a relaciones binarias del tipo 1: N.
Así, por ejemplo, una ocurrencia de "trabajador" puede tener N ocurrencias "persona52
dependiente" asociadas, donde además, la existencia de las ocurrencias en la segunda
entidad depende de la existencia de una ocurrencia que le corresponda en la primera
entidad. Por ejemplo, en el modelo habrá personas dependientes de un trabajador sólo si ese
trabajador existe. La llave de una entidad débil se forma combinando la llave de la entidad
regular que la determina con algún otro atributo que defina unívocamente cada entidad
débil asociada a una entidad regular dada. (Una entidad se denomina regular si no es débil).
En una relación, la llave es la combinación de las llaves de todas las entidades asociadas.
Para cada relación se determina su tipo (simple o complejo) y en el DER se escribe el tipo
de correspondencia. Por ejemplo, una empresa puede tener varios (n) trabajadores
asociados y un trabajador pertenece a una sola empresa (1). En la relación TrabajadorMáquina-Pieza, un trabajador puede trabajar en n máquinas, produciendo p piezas, o una
pieza puede ser producida por m trabajadores en n máquinas. Aquí, m, n y p no identifican
un número específico, sino solamente el tipo de correspondencia que se establece en la
relación.
El Modelo Entidad-Relación.
-
Se elabora el diagrama (o diagramas) entidad-relación.
-
Se completa el modelo con listas de atributos y una descripción de otras
restricciones que no se pueden reflejar en el diagrama.
Dado lo rudimentario de esta técnica se necesita cierto entrenamiento y experiencia para
lograr buenos modelos de datos.
El modelado de datos no acaba con el uso de esta técnica. Son necesarias otras técnicas para
lograr un modelo directamente implementable en una base de datos. Brevemente:
-
Transformación de relaciones múltiples en binarias.
-
Normalización de una base de datos de relaciones (algunas relaciones pueden
transformarse en atributos y viceversa).
53
-
Conversión en tablas (en caso de utilizar una base de datos relacional).3
4.2.3. Diagrama de Clases
Un diagrama de clases es un tipo de diagrama estático que describe la estructura de un
sistema mostrando sus clases, atributos y las relaciones entre ellos. Los diagramas de clases
son utilizados durante el proceso de análisis y diseño de los sistemas, donde se crea el
diseño conceptual de la información que se manejará en el sistema, y los componentes que
se encargarán del funcionamiento y la relación entre uno y otro.4
Titulo
Descripción
Fecha
Autor/Fuente
Figura 9
Ejemplo de diagrama de clases
18/10/2012
Gustavo Justicia, Lucia Del Pino
4.2.4. Diagrama de Componentes
Un diagrama de componentes muestra las dependencias lógicas entre componentes
de software, sean éstos componentes fuentes, binarios o ejecutables, ilustran las
3
http://www.ecured.cu/index.php/Diagrama_Entidad_Relaci%C3%B3n
4
http://es.wikipedia.org/wiki/Diagrama_de_clases
54
piezas del software, controladores embebidos, etc. Los diagramas de Componentes
prevalecen en el campo de la arquitectura de software pero pueden ser usados para
modelar y documentar cualquier arquitectura de sistema, es decir para describir la
vista de implementación estática de un sistema. Los diagramas de componentes se
relacionan con los diagramas de clases, ya que un componente normalmente se
corresponde con una o más clases, interfaces o colaboraciones pero un diagrama de
Componentes tiene un nivel más alto de abstracción que un diagrama de clase,
usualmente un componente se implementa por una o más clases (u objetos) en
tiempo de ejecución. Estos son bloques de construcción, como eventualmente un
componente puede comprender una gran porción de un sistema
Para todo sistema OO se han de construir una serie de diagramas que modelan tanto
la parte estática, como de la parte dinámica, pero llegado el momento todo esto se
debe materializar en un sistema implementado.
Los componentes software tienen tipo, que indica si son útiles en tiempo de
compilación, enlace o ejecución. Se consideran en este tipo de diagramas solo tipos
de componentes. Instancias específicas se encuentran en el diagrama de ejecución.
Los componentes son similares en práctica a los diagramas de paquete como los
límites definidos y se usan para agrupar elementos en estructuras lógicas. La
diferencia entre Diagramas de Paquete y Diagramas de Componente es que los
diagramas de componente ofrecen un mecanismo de agrupamiento más rico
semánticamente. Con los Diagramas de Componente todos los elementos del
modelo son privados mientras que los diagramas de Paquete solo muestran ítems
públicos.
Utilización de los diagramas de componentes:
55
Los diagramas de componentes pueden ser utilizados para modelar sistema de
software de cualquier tamaño y complejidad. La herramienta no permite especificar
un componente como unidad modular con interfaces bien definidos, reemplazable
dentro de su ambiente.
El concepto de componente encaja dentro de las ideas de desarrollo basado en
componentes y estructuración de sistemas basada en componentes, en las cuales un
componente se va modelando a través de todo el ciclo de desarrollo y
sucesivamente se va refinando hasta llegar a su implantación y creación de su “run
time” módulo ejecutable. Un componente puede ser considerado como una unidad
autónoma, dentro de un sistema o subsistema, tiene uno o mas interfaces
proporcionados o requeridos y sus interioridades permanecen ocultas e inaccesibles,
con expresión de la forma que esta previa e sus interfaces.
Si los componentes se diseñan de tal forma que puedan ser tratados tan
independientemente como sea posible, esos componentes y los subsistemas que
ellos conforman, podrán ser reutilizados y sustituidos en forma flexible,
conectándolos a través de sus interfaces. Así mismo, una vez desinstalados, esos
componentes pueden ser re implementados independientemente, cuando sea
necesario actualizar las funciones de un sistema en producción5
4.3. Análisis de requerimientos de software.
Para el análisis de requerimientos de software nos basamos en la planificación de
requerimientos de acuerdo a la metodología RAD, realizamos la validación de los actores
5
virtual.usalesiana.edu.bo/web/practica/archiv/compon.doc
56
principales del sistema con el personal clave de la compañía, roles y permisos, así como
las funcionalidades y navegabilidad por cada uno de los actores validados.
4.3.1. Roles
Identificamos los roles principales de usuarios del sistema y definimos 2 usuarios
con los siguientes privilegios:
-
Representante de la Dirección: El Representante de la Dirección es el encargado
de aprobar todos los documentos para garantizar la correcta aplicación de los
estándares de las normativas adoptadas por la empresa y de entes reguladores.
Como parte importante el representante de la dirección además, es el encargado de
otorgar permisos de revisión a los demás empleados de la compañía cuando así lo
amerite, por cada documento. El Representante de la Dirección además juega un
papel importante en la administración de toda la documentación, procedimientos y
gestión de permisos del personal que pueda acceder a visualizar dicha
documentación.
-
Coordinador: El Coordinador es el personal encargado de delegar la creación de
documentación a los diferentes responsables, generalmente el Coordinador es la
persona dueña de los procesos de negocio, debido a ésto el Coordinador es el
encargado principal de la Gestión de Procesos de Negocio, quien diseña y
determina los procesos de la compañía y la relación que tienen estos entre sí, y con
la diferente documentación de la compañía.
El Coordinador adicionalmente debe tomar parte activa en la revisión de
documentación realizada por los responsables, o definir que documentos pueden ser
visualizados por los diferentes empleados en la compañía. Toda la documentación
revisada por el Coordinador deberá ser finalmente aprobada por el Representante
de la Dirección para ser depositada de manera definitiva en la LMD.
57
-
Responsable: El Responsable es definido como el empleado encargado de realizar
la documentación delegada por parte del Coordinador o, en ciertos casos el
Representante de la Dirección. El responsable adicionalmente deberá realizar el
respectivo monitoreo a los documentos que ha realizado y de ser el caso y requerir
una actualización del documento solicitar al Coordinador o al Representante de la
Dirección la gestión de realización del mismo.
-
Administrador de Seguridad: El administrador de seguridad está definido como
un rol exclusivamente para la gestión de usuarios y las opciones que pueda tener en
el sistema, si bien en la compañía no se cuenta con personal específico para realizar
esta tarea, se asignará dentro de la compañía un responsable de la administración
de seguridad del sistema.
4.3.2. Especificación de Funcionalidades
4.3.2.1. Funcionalidades Generales
El sistema desarrollado será capaz de permitir al personal de LOGICA
mantener un correcto control de documentos en base a la Norma
ISO9001:2008.
4.3.2.2. Funcionalidades Específicas
Se definió con el personal clave de la empresa LOGICA las funcionalidades del sistema las
cuales fueron divididas por las responsabilidades y roles definido anteriormente:
4.3.2.3. Funcionalidades para el Representante de la Dirección:

Gestión de documentos
o
Aprobación de documentos
58


o
Revisión de documentos
o
Creación de documentos
o
Búsqueda de documentos
o
Visualización de documentos
o
Visualización de la LMD general
o
Delegación de creación de documentos
o
Delegación de modificación de versión de documentos
o
Asignación de permisos de lectura
o
Revocación de permisos de lectura
o
Vinculación de documentos con procesos del negocio
o
Desvinculación de documentos con procesos del negocio
Gestión de Procesos
o
Creación de procesos
o
Eliminación de Procesos
o
Modificación de Procesos
o
Visualización de Procesos
o
Vinculación con otros procesos del negocio
o
Desvinculación de procesos del negocio
o
Ingreso de diagramas de procesos
Revisión de Notificaciones
o

Visualizar Notificaciones
Gestión de Cambios
o
Solicitud de creación de usuarios
o
Solicitud de eliminación de usuarios
o
Solicitud de modificación de usuarios
59
4.3.2.4. Funcionalidades para el Coordinador:



Gestión de documentos
o
Revisión de documentos
o
Creación de documentos
o
Búsqueda de documentos
o
Visualización de documentos
o
Delegación de creación de documentos
o
Delegación de modificación de versión de documentos
o
Asignación de permisos de lectura
o
Revocación de permisos de lectura
o
Vinculación de documentos con procesos del negocio
o
Desvinculación de documentos con procesos del negocio
Gestión de Procesos
o
Creación de procesos
o
Eliminación de Procesos
o
Modificación de Procesos
o
Visualización de Procesos
o
Vinculación con otros procesos del negocio
o
Desvinculación de procesos del negocio
o
Ingreso de diagramas de procesos
Revisión de Notificaciones
o

Visualizar Notificaciones
Gestión de Cambios
o
Solicitud de cambio en documentos

Solicitud de revocación de permisos

Solicitud de asignación de permisos
60

Solicitud de creación de nuevo documento

Solicitud de dar de baja documento
o
Solicitud de creación de usuarios
o
Solicitud de eliminación de usuarios
o
Solicitud de modificación de usuarios
4.3.2.5. Funcionalidades para el Responsable:


Gestión de documentos
o
Creación de documentos
o
Búsqueda de documentos
o
Visualización de documentos
Gestión de Procesos
o

Revisión de Notificaciones
o

Visualización de Procesos
Visualizar Notificaciones
Gestión de Cambios
o
Solicitud de cambio en documentos

Solicitud de creación de nuevo documento

Solicitud de dar de baja documento
4.3.2.6. Funcionalidades para el Administrador de Seguridad:


Gestión de Usuarios
o
Modificar usuario
o
Modificar cuentas de usuario
o
Bloquear usuario
Gestión de Perfiles
61
o
Creación de perfiles
o
Modificación de opciones por perfil
4.3.3. Diagramas de caso de uso
Una vez terminada la definición de funcionalidades se detalla a continuación la
diagramación de las mismas. Realizamos diagramas UML de casos de uso para el
entendimiento general de las funcionalidades del sistema por parte del personal
clave de LOGICA.
62
4.3.3.1. Diagrama de Casos de Uso General
F.1 Ingreso al Sistema
F.2 Revisión de
Notificaciones
Responsable
F.3 Control de Documentos
F.4 Administración de
Procesos de Negocio
Coordinador/Representante
de la Dirección
F.5 Administración de
Usuarios
Administrador de
Seguridad
F.6 Administración de
Perfiles
F.7 Administración de
Grupos
F.8 Generar Solicitudes de
cambio
F.9 Administrar Cuenta de
Usuario Activo
F.10 Apariencia de
Escritorio
Titulo
Descripción
Fecha
Autor/Fuente
Figura 10
Diagrama general de caso
de uso
18/10/2012
Gustavo Justicia, Lucia
Del Pino
63
4.3.3.2. Diagramas de caso de uso a detalle
Los diagramas de caso de uso a detalle se encuentran documentados
en el anexo.
4.4. Especificaciones de Funcionalidades.

El sistema permitirá la administración de usuarios y grupos:

El sistema permitirá almacenar los documentos.

El sistema permitirá al usuario aprobar, revisar los documentos.

El sistema permitirá al usuario leer los documentos.

El sistema permitirá restringir las versiones de los documentos.

El sistema permitirá enviar notificaciones entre los miembros de la oficina.

El sistema tendrá un control de seguridad que será manejado por el Representante de
la dirección.

Los usuarios podrán solicitar por medio del sistema cambios a los documentos los
cuales serán aprobados por Representante de la dirección.

Los usuarios podrán solicitar cambios a usuarios al Representante de la dirección.

El representante de la dirección o usuario encargado podrá delegar permiso para ver
los documentos aprobados.

El sistema informará a los usuarios cuando se necesite cambiar el estado de un
documento
4.5. Especificaciones de Arquitectura.
4.5.1. Arquitectura de software
La arquitectura utilizada para la realización del proyecto, fue una arquitectura de software,
cliente/servidor multicapa debido a la posibilidad que tiene el sistema de incrementar en
64
funcionalidad y complejidad. Por motivo de interfaz de usuario y, debido a que la
aplicación se mantendrá en un ambiente tecnológico de nivel de complejidad bajo, es decir
los usuarios del sistema serán entre 3 a 10 personas.
Las capas utilizadas para el desarrollo de la aplicación se determinaron como las
siguientes:
 Capa de Negocio
 Capa de Utilidades
 Capa de Persistencia
 Capa de Interfaz Gráfica
Título
Descripción
Fecha
Autor/Fuente
Figura 11. Capas del sistema
Representación de los niveles y capas de la
arquitectura del sistema desarrollado
18/10/2012
Gustavo Justicia, Lucia Del Pino
4.5.1.1. Capa de Negocio
En esta capa se encuentran distribuidos todos los lineamientos y la lógica del
negocio utilizada para realizar la interacción entre la interfaz de usuario y la
persistencia de datos, adicionalmente esta capa se encuentra vinculada de manera
importante con la capa de utilidades.
65
4.5.1.2. Capa de Utilidades
La capa de utilidades es extensamente vinculada con la capa de negocio, esto se
debe a que se utilizan y re-utilizan varias utilidades y clases para la generación de
información de la capa de negocio. En la capa de utilidades se encuentran
distribuidos todos los componentes que asisten de manera directa o indirecta a la
lógica del negocio.
4.5.1.3. Capa de Persistencia
La capa de persistencia de datos es manejada directamente por Hibernate, esta capa
es accedida por la Capa de Utilidades y la Capa de Negocio para realizar la correcta
persistencia de datos. Las clases incluidas en la capa de persistencia de datos
ayudan a realizar un mapeo directo con las tablas distribuidas sobre el motor de
base de datos. Existe una sincronización entre estas tablas y los objetos de esta
capa.
4.5.1.4. Capa de Interfaz Gráfica de Usuario
La capa de interfaz de usuario está diseñada para albergar todo lo referente a
visualización y facilitación de la interacción del usuario final con el sistema, esta
capa nos ayuda a mostrar ambientes de interfaz gráfica generalmente más
complejos que los generados por medios WEB, con relativa facilidad para mostrar
la información necesaria a los usuarios finales
66
4.5.2. Componentes de Interacción
Título
Descripción
Fecha
Autor/Fuente
El sistema
Figura 12. Diagrama de despliegue
Diagrama de despliegue de la aplicación,
indicando sus componentes y cómo interactúan
18/10/2012
Gustavo Justicia, Lucia Del Pino
funciona sobre una máquina virtual java, este a su vez se mantiene
interconectado mediante un pool de conexiones creados por Hibernate a una instancia del
motor de base de datos, el sistema a su vez se mantiene activamente recibiendo y enviando
notificaciones mediante correo electrónico, motivo por el cual todos los usuarios del
sistema deberán tener una cuenta de correo electrónico para la correcta utilización del
sistema. Los protocolos de envío y recepción de correos electrónicos a utilizar, soportados
por la arquitectura actual del sistema son IMAP y SMTP. Ambos tendrán la posibilidad de
realizar las conexiones mediante protocolos adicionales de transporte seguros, en el caso de
esta aplicación por SSL o TLS, de tal manera que se podrá mantener una conexión segura
para la transmisión de datos. Sin embargo la anteriormente mencionada funcionalidad de la
aplicación no es una función crítica del sistema debido a que únicamente se utiliza como un
67
método de notificación entre los diferentes actores del sistema. No existe el transporte de
datos sensibles por medio de estas comunicaciones.
68
CAPÍTULO V
DESARROLLO DE LA APLICACIÓN
Se describe lo esencial del desarrollo de la aplicación siguiendo la metodología RAD, se
explica brevemente el detalle de las herramientas utilizadas, leguaje de programación, por que
fueron escogidos para la elaboración del desarrollo, los diagramas que constan en la fase de
diseño y el prototipo del aplicativo, para terminar se detalla la parte de la construcción la cual
consiste en seis pasos esenciales los cuales son : Implementación, pruebas, fase de transición,
seguridades, despliegue y mantenimiento los cuales serán explicados
5.1. Lenguaje de programación
Después de analizar varias opciones de lenguajes de programación hemos definido usar
Java, puesto que es un lenguaje robusto, simple ya que posee una curva de aprendizaje
muy rápida.
Java es un lenguaje orientado a objetos, posee características de encapsulación de
métodos y funciones y datos. Java maneja un sistema de ejecución de tiempo real basado
en una máquina virtual llamada JVM, está máquina virtual realiza una compilación en
tiempo real de su byte-code, el cual permite una rápida respuesta al utilizarse en sistemas
de cualquier plataforma. El lenguaje además posee de la capacidad de manejar diferentes
hilos de procesamiento lo cual permite un nivel de ejecución paralelo entre los diferentes
componentes del desarrollo de software realizado con este lenguaje.
Las ventajas primordiales que vimos en utilizar Java como lenguaje de programación para
el proyecto fue:
 Es un lenguaje de código abierto y como usuarios no tendremos que luchar contra
impuestos sobre patente anuales
69
 Es independiente de plataforma y estamos libres de usar cualquier IDE para
desarrollo
 El lenguaje de programación java es seguro puesto que encapsula sus datos y nos
permitirá manejar con confianza información confidencial.
 Este lenguaje al ser parte de la formación profesional impartida a lo largo de la
carrera, es un lenguaje conocido y dominado por el equipo de desarrollo.
5.2. Herramientas utilizadas
5.2.1. Power Designer 15.2.
En la elaboración de los UML escogimos realizar con power designer puesto que
fue la herramienta con la cual se ha trabajado en las materias de Ingeniería de
software II, dictada por el ingeniero Fabián De La Cruz y de la cual se tiene un
conocimiento solido del funcionamiento y metodología de trabajo.
Power Designer, es una herramienta de modelado poderosa, la cual ha formado
parte de las mejores aplicaciones para el modelamiento de procesos de negocio, y
principalmente para el caso de desarrollo de software en particular, en el modelado
de diagramas UML. Esta herramienta permite a las empresas, de manera más fácil,
visualizar, analizar y manipular metadatos, logrando un efectiva arquitectura
empresarial de información.
PowerDesigner en cuanto a Arquitectura Empresarial también brinda un enfoque
basado en modelos, el cual permite alinear al negocio con la tecnología de
información, facilitando la implementación de arquitecturas efectivas de
información empresarial. Brinda potentes técnicas de análisis, diseño y gestión de
metadatos a la empresa.
PowerDesigner
combina
varias
técnicas
estándar
de
modelamiento con
herramientas líder de desarrollo, como .NET, Sybase WorkSpace, Sybase
Powerbuilder, Java y Eclipse, para darle a las empresas soluciones de análisis de
70
negocio y de diseño formal de base de datos. Además trabaja con más de 60 bases
de datos relacionales.
Beneficios
-
Mejor calidad al momento de alinear el negocio con las tecnologías de la
información.
-
Su nivel de personalización es ampliamente alta, permitiendo acogerse a los
estándares y regulaciones internacionales, así como normativas específicas
de la empresa a la cual pertenezca el software a ser desarrollado.
-
Facilita la arquitectura empresarial, documentando los sistemas existentes.
5.2.2. Herramienta de desarrollo
Después de realizar la selección del lenguaje de programación analizamos
los distintos IDE que se encuentran en el mercado y nos inclinamos por la
opción de Netbeans por las siguientes ventajas que nos presenta este IDE:
NetBeans es un entorno de desarrollo integrado libre, hecho principalmente
para el lenguaje de programación Java. Existe además un número
importante de módulos para extenderlo. NetBeans IDE es un producto libre
y gratuito sin restricciones de uso.
NetBeans es un IDE con una comunidad en constante crecimiento, y con
cerca de 100 socios en todo el mundo.
La plataforma de NetBeans permite que las aplicaciones sean desarrolladas
a partir de un conjunto de componentes de software llamados módulos. Un
módulo es el conjunto de clases java especificadas para interactuar con las
diferentes APIs de NetBeans y un archivo especial (manifest file) que lo
71
identifica como módulo. Las aplicaciones construidas a partir de módulos
pueden ser extendidas agregándole nuevos módulos. Debido a que los
módulos pueden ser desarrollados independientemente.
Otra de las ventajas analizadas para el proyecto es la facilidad de
integración con el framework Hibernate, el cual es una parte esencial del
proyecto ya que con Hibernate, tenemos una total independencia con el
motor de base de datos , independizando de manera total la capa de datos
con la capa de lógica de negocio por lo cual únicamente con añadir un
archivo de conexión se puede tener acceso a cualquier motor de base de
datos . Gracias a esta integración tendremos los datos en un cache de
memoria, estos datos dependiendo de la manera de configuración de
Hibernate residirán en la memoria principal al momento de generar una
sesión de Hibernate, esto quiere decir que los sucesivos accesos a la base
de datos utilizarán recursos mínimos para la consulta de datos en memoria.
5.2.3. Motor de base de datos
Para seleccionar el motor de base de datos optamos por analizar las ventajas
que nos brindan los motores que teníamos conocimiento y llegamos a la
conclusión que MYSQL nos brinda una gran expectativa para el desarrollo
entre estas encontramos las siguientes:
1. Escalabilidad y flexibilidad
El servidor de bases de datos MySQL ofrece lo último en escalabilidad, siendo
capaz de manejar bases de datos empotradas ocupando sólo 1MB, y hacer
funcionar data warehouses que contengan terabytes de información. La
flexibilidad de plataforma es una característica clásica de MySQL, soportando
72
distintas versiones de Linux, UNIX y Windows Y, por supuesto, la naturaleza
open source de MySQL permite una personalización completa para aquellos
que deseen añadir características al servidor.
2.
Alto rendimiento
Una arquitectura única de motores de bases de datos permite a los profesionales
configurar el servidor MySQL para aplicaciones específicas, dando como
resultado un rendimiento espectacular MySQL puede cumplir con las
expectaciones de rendimiento de cualquier sistema, ya sea un sistema de
procesamiento transaccional de alta velocidad, o un sitio web de gran volúmen
sirviendo un billón de consultas diarias MySQL ofrece la munición adecuada
para sistemas críticos mediante herramientas de carga de alta velocidad, índices
full-text y otros mecanismos de mejora del rendimiento.
3. Alta disponibilidad
Solidez y disponibilidad constante son características distintivas de MySQL,
con clientes confiando en ellas para garantizar el uptime en todo momento
MySQL ofrece una amplia variedad de soluciones de alta disponibilidad, desde
replicación a servidores de cluster especializados, u ofertas de terceros.
4. Robusto soporte transaccional
MySQL ofrece uno de los motores de bases de datos transaccionales más
potentes del mercado. Las características incluyen un soporte completo de
ACID (atómica, consistente, aislada, duradera), bloqueo a nivel de filas,
posibilidad de transacciones distribuidas, y soporte de transacciones con
múltiples versiones donde los lectores no bloquean a los escritores y viceversa
73
También se asegura una integridad completa de los datos mediante integridad
referencial, niveles de aislamiento de transacciones especializados, y detección
de deadlocks.
5.
Fortalezas en Web y Data Warehouse
MySQL es el estándar de-facto para sitios web de gran tráfico por su motor de
consultas de alto rendimiento, su posibilidad de insertar datos a gran velocidad,
y un buen soporte para funciones web especializadas como las búsquedas
fulltext. Estas mismas fortalezas también se aplican a entornos de data
warehousing, donde MySQL escala hasta el rango de los terabytes tanto para un
solo servidor, como para varios. Otras características como las tablas en
memoria, índices B-tree y hash, y tablas comprimidas hasta un 80% hacen de
MySQL una buena opción para aplicaciones web y de business intelligence.
6.
Fuerte protección de datos
Porque proteger los datos es el trabajo principal de los profesionales de bases de
datos, MySQL ofrece características de seguridad que aseguran una protección
absoluta de los datos En cuanto a autenticación, MySQL ofrece potentes
mecanismos para asegurar que sólo los usuarios autorizados tienen acceso al
servidor. También se ofrece soporte SSH y SSL para asegurar conexiones
seguras. Existe una estructura de privilegios que permite que los usuarios sólo
puedan acceder a los datos que se les permite, así como potentes funciones de
cifrado y descifrado para asegurarse de que los datos están protegidos
Finalmente, se ofrecen utilidades de backup y recuperación por parte de
74
MySQL y terceros, que permiten copias completas, tanto lógicas como físicas,
así como recuperación point-in-time.
7. Desarrollo de aplicaciones completo
Uno de los motivos por los que MySQL es las bases de datos open source más
popular es que ofrece un soporte completo para cualquier necesidad de
desarrollo. En la base de datos se puede encontrar soporte para procedimientos
almacenados, triggers, funciones, vistas, cursores, SQL estándar, y mucho más.
Existen librerías para dar soporte a MySQL en aplicaciones empotradas.
También se ofrecen drivers (ODBC, JDCBC,…) que permiten que distintos
tipos de aplicaciones puedan usar MySQL como gestor de bases de datos. No
importa es PHP, Perl, Java, Visual Basic, o .NET, MySQL ofrece a los
desarrolladores todo lo que necesitan para conseguir el éxito en el desarrollo de
sistemas de información basados en bases de datos.
8. Facilidades de gestión
MySQL ofrece posibilidades de instalación excepcionales, con un tiempo
medio desde la descarga hasta completar la instalación de menos de quince
minutos. Esto es cierto sin importar que la plataforma sea Windows, Linux,
Macintosh, o UNIX Una vez instalado, características de gestión automáticas
como expansión automática del espacio, o los cambios dinámicos de
configuración descargan parte del trabajo de los atareados administradores.
MySQL también ofrece una completa colección de herramientas gráficas de
gestión que permiten al DBA gestionar, controlar y resolver problemas en
varios servidores desde una misma estación de trabajo. Además, hay multitud
75
de herramientas de terceros que gestionan tareas como el diseño de datos y
ETL, administración, gestión de tareas y monitorización.
9. Open Source y soporte 24 / 7
Muchas empresas no se atreven a adoptar software open source porque creen
que no podrán encontrar el tipo de soporte o servicios profesionales en los que
confían
con
su
software
propietario
actual.
Las
preguntas
sobre
indemnizaciones también aparecen. Estas preocupaciones pueden desaparecer
con el completo servicio de soporte e indemnización disponibles. MySQL no es
un proyecto típico Open Source ya que todo el software es propiedad de
MySQL AB, lo que permite un modelo de coste y soporte que ofrezca una
combinación única entre la libertad del open source y la confianza de un
software con soporte.
10. Coste Total de Propiedad menor
Al migrar aplicaciones actuales a MySQL, o usar MySQL para nuevos
desarrollos, las empresas están ahorrando costes que muchas veces llegan a las
siete cifras. Las empresas están descubriendo que, gracias al servidor MySQL y
las arquitecturas scale-out que utilizan hardware económico, pueden alcanzar
niveles sorprendentes de escalabilidad y rendimiento, y todo a un coste bastante
menor que el de los sistemas propietarios. Además, la robustez y facilidad de
mantenimiento de MySQL implican que los administradores no pierden el
tiempo con problemas de rendimiento o disponibilidad, sino que pueden
concentrarse en tareas de mayor impacto en el negocio.6
6
http://warp.es/mysql/productos/razones/
76
5.2.4. Hibernate
Hibernate es una herramienta de Mapeo objeto-relacional (ORM) para la
plataforma Java (y disponible también para .Net con el nombre de
NHibernate) que facilita el mapeo de atributos entre una base de datos
relacional tradicional y el modelo de objetos de una aplicación, mediante
archivos declarativos (XML) o anotaciones en los beans de las entidades
que permiten establecer estas relaciones.
Hibernate es software libre, distribuido bajo los términos de la licencia
GNU LGPL.
Características

No intrusivo (estilo POJO)

Muy buena documentación (forums para ayuda, libro)

Comunidad activa con muchos usuarios

Transacciones, caché, asociaciones, polimorfismo, herencia,
lazy loading, persistencia transitiva, estrategias de fetching.

Potente lenguaje de consulta (HQL): subqueries, outer joins,
ordering, proyeccion (report query), paginación.

Fácil testeo.

No es estándar.
Agregamos al proyecto la herramienta de Hibernate puesto que nos permite
realizar un mapeo de la base de datos de un modelo ER a un modelo
orientado a objetos. La manipulación de datos se vuelve transparente y no
77
se requiere apegarse a una tecnología específica de motor de base de datos
las ventajas que nosotros vimos de usar Hibernate son:

Facilidad en la programación

Facilidad en la manipulación de datos

Apta para aplicaciones transaccionales sin procesamiento masivo.

Es flexible en cuanto al esquema de tablas utilizado, para poder
adaptarse a su uso sobre una base de datos ya existente. También
tiene la funcionalidad de crear la base de datos a partir de la
información disponible.

Fácil de entender e implementar
5.3. Fase de Diseño
En la fase de diseño ,después de realizado el levantamiento de la información con el cliente,
acerca de los requerimientos del sistema y definición de arquitectura, se dio paso al diseño
del modelo de base de datos, diagramas de clases y paquetes que reflejen la arquitectura
diseñada para este proyecto de desarrollo de software.
5.3.1. Diagrama BD
78
Figura 13
Modelo entidad relación de la base
Descripción de datos
18/10/2012
Fecha
Gustavo Justicia, Lucia Del Pino
Autor
Titulo
79
5.3.2. Diagrama de paquetes
A continuación se indican
todos los paquetes utilizados para el desarrollo de la
DocBPM
aplicación, estos
paquetes contienen las diferentes clases que pertenecen a la
+ main (final String args[]) : void
aplicación.
business
entity
models
visual
Titulo
Descripción
Fecha
Autor/Fuente
Figura 14
Diagrama general de paquete.
18/10/2012
Gustavo Justicia, Lucia Del Pino
5.3.3. Diagrama de clases
A continuación se detallan los diagramas de clases que representan la interacción
de los diferentes componentes a ser desarrollados, los diagramas de clases están
agrupados en diferentes paquetes de acuerdo a la arquitectura tomada para la
realización del proyecto la cual, es explicada en el punto 4.5.1 y su diagrama en el
punto 5.3.2.
5.3.3.1. PAQUETE COM.INTEGRAITEC.DOCBPM.BUSINESS
80
Documentos::AccionDocumentoRevisar
Procesos
* documento
: String
* version
: String
* docAguardar : Documento
* proceso
: Proceso
- modelo
: ProcesoTreeTableModel
* procesos
: List<Proceso>
* generacionUsada : int
- nodos
: LinkedList<ProcesoTreeTableNode>
+ <<Constructor>> AccionDocumentoRevisar (String documento
, String version)
+
actionPerformed (ActionEvent e)
: void
Documentos::AccionDocumentoAprobar
* documento
: String
* version
: String
* docAguardar : Documento
+ <<Constructor>> AccionDocumentoAprobar (String documento
, String version)
+
actionPerformed (ActionEvent e)
: void
Documentos
* usuarioConectado : Usuario
* documentosLista : List<Documento>
* modelo
: DocumentosTreeTableModel
- nodos
: LinkedList<DocumentoTreeTableNode>
* sesionAbierta
: Session
* sesionAux
: Session
+ getModelo ()
+ setModelo (DocumentosTreeTableModel mode
lo)
+ crearSesion ()
+ abrirSesion ()
+ cerrarSesion ()
+ asignarPermisoDocumento (Usuario usuario
, Documento doc)
+ getDocumentoByID (String id,
String version)
+ getDocumentoByIDSesionAbierta (String id
, String version)
+ getContaDocumentosPorId (String id)
+ getContaDocumentos ()
+ getContaDocumentosNuevos ()
+ cargarDocsAprobarPorUsuario (Usuario usu
arioC)
+ cargarDocsRevisarPorUsuario (Usuario usu
arioC)
+ cargarDocsCrearPorUsuario (Usuario usuar
ioC)
+ cargarDocsLMD (Usuario usuarioC)
+ crearModelo ()
+ crearIdentificadoresArbol ()
+ generarModelo (List identificadores)
+ generarNodo (Documento valor)
+ cargarArbolDeDocumentosAprobados ()
+ setDocumentoFile (byte documento[],
Documento documentoAguardar)
+ guardarDocumento (Documento documento)
+ setProcesosRelacioados (Set procesosArel
acionar, Documento documento)
+ tipoDocumentoPorExtension (String extens
ion)
- insertarDocumentoArbol (DocumentoTreeTab
leNode padre,
DocumentoTreeTableNode hijo)
+ setUsuarioDefault (Usuario usuarioConect
ado)
+ revocarPermisoDocumento (Usuario next,
Documento documento)
+ removerProcesosRelacioados (HashSet proc
esosRelacionados, Documento documento)
<<Unresolved Interface>>
ActionListener
(event)
= new LinkedList<DocumentoTreeTableNode>()
: DocumentosTreeTableModel
: void
: void
: void
: void
: void
: Documento
Documentos::AccionDocumentoSubir
: Documento
* documento
: String
* version
: String
* docAguardar : Documento
: int
: int
: int
: DefaultTableModel
+
+ <<Constructor>> AccionDocumentoSubir (String documento,
String version)
+
actionPerformed (ActionEvent e)
: void
: DefaultTableModel
+
+
+
+
: DefaultTableModel
+
:
:
:
:
:
:
:
=0
= new LinkedList<ProcesoTreeTableNode>()
+ <<Constructor>> Procesos ()
+ <<Constructor>> Procesos (Proceso proceso)
+
getProceso ()
+
setProceso (Proceso proceso)
+
getProcesos ()
+
setProcesos (List<Proceso> procesos)
+
crearModelo ()
+
crearModeloConRelaciones ()
+
crearModeloConRelaciones (Documento docu
mento)
+
crearIdentificadores ()
+
crearIdentificadoresPlus ()
+
cargarArbolDeProcesos ()
+
cargarArbolDeProcesos (ProcesoTreeTableM
odel modelo)
+
recargarProcesos ()
+
generarModelo (List identificadores)
+
generarModeloPlus (List identificadores,
Proceso procesoRel)
+
setColumnasModelo (DefaultTreeTableModel
modelo, List identificadores)
+
generarNodo (Proceso valor)
+
insertarHijo (ProcesoTreeTableNode padre
, ProcesoTreeTableNode hijo)
+
setHijoPonderado (ProcesoTreeTableNode p
adre, final ProcesoTreeTableNode hijo)
+
getProcesoByID (String id)
+
generarPonderacionPadreRaiz (final Proce
soTreeTableNode nuevoProceso)
+
existeDepedencias (Proceso padre)
+
generarPonderacion (ProcesoTreeTableNode
padre, final ProcesoTreeTableNode hijo)
+
guardarProceso (Proceso procesoAguardar)
+
insertarHijoPonderado (final ProcesoTree
TableNode padre,
final ProcesoTreeTableNode hijo,
String nombre, String descripcion,
String ponderacionNivel[])
DefaultTableModel
void
List
DocumentosTreeTableModel
DocumentoTreeTableNode
void
void
insertarHijoRaiz (final ProcesoTreeTable
Node nuevoNodo, String id,
String nombre, String descripcion)
getModelo ()
setModelo (ProcesoTreeTableModel modelo)
getNodos ()
setNodos (LinkedList<ProcesoTreeTableNod
e> nodos)
setDocumentosRelacionados (Set documento
s, Proceso proceso)
setProcesosRelacionados (HashSet proceso
sArelacionar, Proceso proceso)
countSubprocesos ()
removerProceso (Proceso proceso)
removerProcesosRelacionados (HashSet pro
cesosRelacionados, Proceso proceso)
generarModeloPlus (List identificadores,
Documento documento)
+
+
+
+
-
: void
: void
:
:
:
:
:
:
:
Proceso
void
List<Proceso>
void
void
void
void
: List
: List
: void
: void
: void
: ProcesoTreeTableModel
: ProcesoTreeTableModel
: void
: ProcesoTreeTableNode
: void
: void
: Proceso
: String
: boolean
: String[]
: void
: void
: void
: ProcesoTreeTableModel
: void
: LinkedList<ProcesoTreeTableNode>
: void
: void
: void
: String
: void
: void
: ProcesoTreeTableModel
: String
: void
: void
: void
: void
AccionDocumentoRevisar
AccionDocumentoAprobar
AccionDocumentoSubir
...
<<Unresolved Class>>
Notificaciones
LoginService
(auth)
* cuentas : Cuentas
+
notificarSolicitudCreacionDocumento (Usu
ario solicitante, Usuario notificado,
String documento, String nota)
: void
+
notificarSolicitudPerfilesUsuarios (Usua
rio solicitante, Usuario notificado,
String usuarioCambio, String nota,
int tipo)
: void
+
notificarSolicitudCambioPerfilDocumento
()
notificarSolicitudCambioPermisoUsuario (
)
notificarCreacion (Usuario solicitante,
Usuario notificado, String documento,
String nota, String fecha)
: void
+
notificarRevision (Usuario solicitante,
Usuario notificado, String documento,
String nota, String fecha)
: void
+
notificarAprobacion (Usuario solicitante
, Usuario notificado, String documento,
String nota, String fecha)
notificarDocumentoListo ()
enviarEmail (Usuario emisor,
List usuariosAnotificar,
String subject, String mensaje)
: void
LoginConnectionService
*
*
*
*
*
*
*
session
usuarioAutenticado
conex
connection
server
SID
esReconfirmacion
:
:
:
:
:
:
:
Session
Usuario
Connection
String
String
String
boolean
= HibernateUtility.getSessionFactory().openSession()
+
= false
+ <<Constructor>> LoginConnectionService (String connectio
n, String server, String dbName,
String dbPass)
+ <<Constructor>> LoginConnectionService (Usuario usuarioC
onectado)
+ <<Constructor>> LoginConnectionService ()
+ <<Getter>>
getSID ()
+
getUsuarioAutenticado ()
+
verificarPrimeraSID (Usuario usuario)
+
verificarSID (Usuario usuario)
+
autenticarSID ()
+
authenticate (String name, char pass[],
String server)
+
closeConnection ()
+
guardarSSO (boolean acepta)
+
: String
: Usuario
: boolean
: boolean
: boolean
: boolean
+
+
: void
: void
Usuarios
cliente
usuarioId
perfil
grupo
usuarioNick
usuarioPassword
usuarioNombre
usuarioApellido
usuarioCargo
usuarioFechaCreacion
usuarioFechaInactivacion
usuarioActivo
usuarioSuperUsuario
usuarioPkey
usuarioFirma
documentosForUsuarioAprobadorId
documentosForUsuarioRevisorId
cuentas
permisoUsuarioDocumentos
documentosForUsuarioCreadorId
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
int
Perfil
Grupo
String
String
String
String
String
Date
Date
boolean
boolean
byte[]
String
Set
Set
Set
Set
Set
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
getUsuarioId ()
setUsuarioId (int usuarioId)
getPerfil ()
setPerfil (Perfil perfil)
getGrupo ()
setGrupo (Grupo grupo)
getUsuarioNick ()
setUsuarioNick (String usuarioNick)
getUsuarioPassword ()
setUsuarioPassword (String usuarioPasswo
rd)
getUsuarioNombre ()
setUsuarioNombre (String usuarioNombre)
getUsuarioApellido ()
setUsuarioApellido (String usuarioApelli
do)
getUsuarioCargo ()
setUsuarioCargo (String usuarioCargo)
getUsuarioFechaCreacion ()
setUsuarioFechaCreacion (Date usuarioFec
haCreacion)
getUsuarioFechaInactivacion ()
setUsuarioFechaInactivacion (Date usuari
oFechaInactivacion)
isUsuarioActivo ()
setUsuarioActivo (boolean usuarioActivo)
isUsuarioSuperUsuario ()
setUsuarioSuperUsuario (boolean usuarioS
uperUsuario)
getUsuarioPkey ()
setUsuarioPkey (byte usuarioPkey[])
getUsuarioFirma ()
setUsuarioFirma (String usuarioFirma)
getDocumentosForUsuarioAprobadorId ()
setDocumentosForUsuarioAprobadorId (Set
documentosForUsuarioAprobadorId)
getDocumentosForUsuarioRevisorId ()
setDocumentosForUsuarioRevisorId (Set do
cumentosForUsuarioRevisorId)
getCuentas ()
setCuentas (Set cuentas)
getPermisoUsuarioDocumentos ()
setPermisoUsuarioDocumentos (Set permiso
UsuarioDocumentos)
getDocumentosForUsuarioCreadorId ()
setDocumentosForUsuarioCreadorId (Set do
cumentosForUsuarioCreadorId)
*
*
*
*
*
*
-
listaFrames
usuarioAutenticado
iconobandeja
opcionesActivas
notificador1
notificacionesEntrantes
bloquearEstacion
botonCambios
botonConfiguracion
botonDocumentos
botonNotificaciones
botonProcesos
escritorioMenu
jButton1
jButton6
jDesktopPane1
jLabel1
jMenu1
jMenu3
jMenuBar1
jMenuItem4
jPanel1
jSeparator1
jSplitPane1
jToolBar1
jXStatusBar1
jXTitledPanel1
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
LinkedList<String>
Usuario
IconoBandejaWindows
LinkedList<Integer>
NotificacionDaemon
NotificacionDaemon
javax.swing.JMenuItem
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JMenuItem
javax.swing.JButton
javax.swing.JButton
javax.swing.JDesktopPane
javax.swing.JLabel
javax.swing.JMenu
javax.swing.JMenu
javax.swing.JMenuBar
javax.swing.JMenuItem
javax.swing.JPanel
javax.swing.JToolBar.Separator
javax.swing.JSplitPane
javax.swing.JToolBar
org.jdesktop.swingx.JXStatusBar
org.jdesktop.swingx.JXTitledPanel
+
+
+
+ <<Constructor>> Usuario (int usuarioId, Perfil perfil,
Grupo grupo, String usuarioNick,
String usuarioPassword,
String usuarioNombre,
String usuarioApellido,
String usuarioCargo,
Date usuarioFechaCreacion,
Date usuarioFechaInactivacion,
boolean usuarioActivo,
boolean usuarioSuperUsuario,
byte usuarioPkey[],
String usuarioFirma,
Set documentosForUsuarioAprobadorId,
Set documentosForUsuarioRevisorId,
Set cuentas,
Set permisoUsuarioDocumentos,
Set documentosForUsuarioCreadorId)
+
+
+
+
Usuario
Usuario
void
void
void
Perfil
Grupo
List
List
DefaultTableModel
DefaultListModel<String>
DefaultListModel<String>
DefaultListModel<String>
DefaultListModel<String>
void
void
+
+
+
+
+
+
+
+
+
getGrupoById (int grupoId)
getGruposList ()
getUsuariosGrupo (Grupo grupo)
getGruposEnSistema ()
guardarGrupo (Grupo grupoAcrear)
crearSesion ()
abrirSesion ()
cerrarSesion ()
setUsuariosGrupo (Grupo grupo,
HashSet<Usuario> usuariosGrupo)
:
:
:
:
:
:
:
:
:
:
int
void
Perfil
void
Grupo
void
String
void
String
void
: String
: void
: String
: void
: String
: void
: Date
: void
getListaFrames ()
getOpcionesActivas ()
setOpcionesActivas (LinkedList<Integer>
opcionesActivas)
+
setListaFrames (LinkedList<String>
listaFrames)
+ <<Constructor>> MainFrame ()
+ <<Constructor>> MainFrame (Usuario usuarioAutenticado)
iniciarNotificador (NotificacionDaemon d
emonio)
pararNotificador (NotificacionDaemon dem
onio)
validarOpciones ()
+
insertarEnDesktop (final JInternalFrame
frame)
initComponents ()
escritorioMenuActionPerformed (java.awt.
event.ActionEvent evt)
usuarioConectado
usuarioAutenticado
jButton6ActionPerformed (java.awt.event.
ActionEvent evt)
botonProcesosActionPerformed (java.awt.
event.ActionEvent evt)
botonDocumentosActionPerformed (java.
awt.event.ActionEvent evt)
botonCambiosActionPerformed (java.awt.
event.ActionEvent evt)
botonNotificacionesActionPerformed (java
.awt.event.ActionEvent evt)
jButton1ActionPerformed (java.awt.event.
ActionEvent evt)
bloquearEstacionActionPerformed (java.
awt.event.ActionEvent evt)
jMenuItem4ActionPerformed (java.awt.
event.ActionEvent evt)
+
getBotonProcesos ()
+
setBotonProcesos (JButton botonProcesos)
: Date
: void
: boolean
: void
: boolean
: void
:
:
:
:
:
:
byte[]
void
String
void
Set
void
: Set
: void
: Set
: void
: Set
: void
: Set
: void
cliente
sesionGeneral
storeGeneral
ultimoMensajeRecibido
padreGeneral
mensajes
:
:
:
:
:
:
DelegacionDocumentos
Usuario
javax.mail.Session
Store
Message
MainFrame
Message[]
* usuarioConectado : Usuario
+ <<Constructor>> ClienteNotificaciones (MainFrame padreGe
neral, Usuario clienteMail)
+
getSessionGeneral ()
+
getStoreGeneral ()
+
mensajeRecibido (Message message)
+
getMensaje (int i)
+
cargarTablaDeNotificacionesRecibidas (St
ore store)
+
mostrarNotificacionesNuevas (Folder fold
er, IconoBandejaWindows notificador)
+
esperarNotificaciones (IconoBandejaWindo
ws notificador, Folder folder)
+
conectarIMAP ()
+ <<Constructor>> DelegacionDocumentos (Usuario usuarioCon
ectado)
+
delegarDocumentoNuevo (Usuario creador,
: void
Usuario revisor, Usuario aprobador,
String NotaCreador, String documento,
String descripcion, Date fechaFinal,
boolean versionable, int versionMax)
: Session
: Store
: MimeMessage
: Message
: DefaultTableModel
Grupo
DefaultListModel<String>
DefaultListModel<String>
DefaultTableModel
void
void
void
void
void
+
+
+
+
+
+
+
+
+
+
: boolean
Perfil
Opcion
DefaultTableModel
DefaultListModel<String>
cuentas
DefaultListModel<String>
void
void
void
void
void
+ getCuentaById (String cuentaId)
+ getCuentaDefaultByUsuario (int usuarioId
)
+ getCuentasDeUsuario (int usuarioId)
+ guardarCuenta (Cuenta cuentaAcrear)
+ crearSesion ()
+ abrirSesion ()
+ cerrarSesion ()
+ <<Constructor>> DocumentosTreeTableModel (DocumentoTreeT
ableNode nodo, List columnas)
+
getValueAt (Object node, int column)
: Object
+
+
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
: JButton
: void
: Cuenta
: Cuenta
: DefaultTableModel
: void
: void
: void
: void
modelo
Proceso
(entity)
-
proId
proceso
proNombre
proDescripcion
proNivel
proVersion
proDiagrama
proDiagramaArchivo
documentos
procesos
procesosForProProId
procesosForProId
:
:
:
:
:
:
:
:
:
:
:
:
String
Proceso
String
String
int
int
byte[]
String
Set
Set
Set
Set
ProcesoTreeTableModel
(models)
* modeloEspecial
: boolean
* esDocumento
: boolean
* procesoRelacionado : Proceso
* docRelacionado
: Documento
* documentos
: Documentos
+
+
+
+
+
+
+
+
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
getProDiagramaArchivo ()
setProDiagramaArchivo (String proDiagram
aArchivo)
getProId ()
setProId (String proId)
getProceso ()
setProceso (Proceso proceso)
getProNombre ()
setProNombre (String proNombre)
getProDescripcion ()
setProDescripcion (String proDescripcion
)
getProNivel ()
setProNivel (int proNivel)
getProVersion ()
setProVersion (int proVersion)
getProDiagrama ()
setProDiagrama (byte proDiagrama[])
getDocumentos ()
setDocumentos (Set documentos)
getProcesos ()
setProcesos (Set procesos)
getProcesosForProProId ()
setProcesosForProProId (Set procesosForP
roProId)
getProcesosForProId ()
setProcesosForProId (Set procesosForProI
d)
= false
= false
= new Documentos()
+ <<Constructor>> ProcesoTreeTableModel (ProcesoTreeTableN
ode nodo, List columnas)
+ <<Constructor>> ProcesoTreeTableModel (ProcesoTreeTableN
ode nodo, List columnas,
Proceso procesoRelacionado)
+ <<Constructor>> ProcesoTreeTableModel (ProcesoTreeTableN
ode nodo, List columnas,
Documento docRelacionado)
+
getValueAt (Object node, int column)
: Object
+ <<Constructor>> Proceso ()
+ <<Constructor>> Proceso (String proId, String proNombre,
int proNivel, int proVersion)
+ <<Constructor>> Proceso (String proId, Proceso proceso,
String proNombre,
String proDescripcion, int proNivel,
int proVersion, byte proDiagrama[],
Set documentos, Set procesos,
Set procesosForProProId,
Set procesosForProId)
: void
: boolean
: void
Cuentas
:
:
:
:
:
:
:
:
:
:
DocumentosTreeTableModel
(models)
: LinkedList<String>
: LinkedList<Integer>
: void
: void
notificarPersonasInvolucradasCreacionIni
cial (Usuario creador, Usuario revisor,
Usuario aprobador, String nota,
String documento, String fecha)
* sesionAbierta : Session
getPerfilById (short perfilId)
getOpcionById (short opcionId)
getPerfilsEnSistema ()
getListaOpciones ()
getOpcionesPerfil (Perfil perfil)
guardarPerfil (Perfil perfilAcrear)
crearSesion ()
abrirSesion ()
cerrarSesion ()
guardarOpcion (Opcion oguardar)
* documentos : Documentos
= new LinkedList<>()
delegarDocumentoVersion (Usuario creador
, Usuario revisor, Usuario aprobador,
String NotaCreador, String documento,
String descripcion, Date fechaFinal,
Documento documentoN)
+
: void
: boolean
* sesionAbierta : Session
:
:
:
:
:
:
:
:
:
+
: void
modelo
MainFrame
(visual)
+ <<Constructor>> Usuario ()
+ <<Constructor>> Usuario (int usuarioId, Perfil perfil,
Grupo grupo, String usuarioNick,
String usuarioPassword,
String usuarioNombre,
String usuarioApellido,
String usuarioCargo,
Date usuarioFechaCreacion,
boolean usuarioActivo,
boolean usuarioSuperUsuario)
+
+
+
+
+
+
+
+
+
+
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
padreGeneral
Usuario
(entity)
-
: void
*
*
*
*
*
*
Perfiles
* sesionAbierta : Session
getUsuarioById (int usuarioId)
getUsuarioByIdSession (int usuarioId)
crearSesion ()
abrirSesion ()
cerrarSesion ()
getPerfilById (short perfilId)
getGrupoById (int grupoId)
getAllGrupos ()
getAllPerfiles ()
getUsuariosEnSistema ()
getListaUsuarios ()
getListaUsuarios (Documento documento)
getListaUsuariosByGrupo (int grupo)
getListaUsuariosByPerfil (short perfil)
guardarUsuario (Usuario usuarioAcrear)
eliminarUsuario (Usuario usuarioById)
: void
Grupos
* sesionAbierta : Session
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
ClienteNotificaciones
= new Cuentas()
+ <<Constructor>> Notificaciones ()
+ <<Constructor>> Notificaciones (Documento documento)
+
notificarSolicitudCambioDocumento (Usuar : void
io solicitante, Usuario notificado,
Documento documento, String nota,
int tipo)
: String
: void
:
:
:
:
:
:
:
:
String
void
Proceso
void
String
void
String
void
:
:
:
:
:
:
:
:
:
:
:
:
int
void
int
void
byte[]
void
Set
void
Set
void
Set
void
: Set
: void
proceso
Documento
(entity)
-
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
DocumentoId
Usuario
Usuario
Usuario
String
byte[]
boolean
boolean
boolean
Date
Date
Date
boolean
Boolean
String
short
Date
boolean
int
boolean
String
Set
Set
Set
Set
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
+ <<Constructor>> Documento ()
+ <<Constructor>> Documento (DocumentoId id,
String documentoNombre,
boolean documentoCreado,
boolean documentoRevisado,
boolean documentoAprobado,
boolean documentoGrupoRevision,
String documentoTipo,
short documentoPrioridad,
Date documentoFechaEntrega,
boolean documentoVersionable,
int documentoVersionmaxima,
boolean documentoExterno)
+ <<Constructor>> Documento (DocumentoId id,
Usuario usuarioByUsuarioRevisorId,
Usuario usuarioByUsuarioCreadorId,
Usuario usuarioByUsuarioAprobadorId,
String documentoNombre,
byte documentoArchivo[],
boolean documentoCreado,
boolean documentoRevisado,
boolean documentoAprobado,
Date documentoFechaCreado,
Date documentoFechaRevisado,
Date documentoFechaAprobado,
boolean documentoGrupoRevision,
Boolean documentoGrupoAprobacion,
String documentoTipo,
short documentoPrioridad,
Date documentoFechaEntrega,
boolean documentoVersionable,
int documentoVersionmaxima,
boolean documentoExterno,
String documentoDescripcion,
Set documentosForFkDocumentoRelacionado
, Set permisoUsuarioDocumentos,
Set procesos,
Set documentosForFkDocumentoRelacionado
2)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Titulo
id
usuarioByUsuarioRevisorId
usuarioByUsuarioCreadorId
usuarioByUsuarioAprobadorId
documentoNombre
documentoArchivo
documentoCreado
documentoRevisado
documentoAprobado
documentoFechaCreado
documentoFechaRevisado
documentoFechaAprobado
documentoGrupoRevision
documentoGrupoAprobacion
documentoTipo
documentoPrioridad
documentoFechaEntrega
documentoVersionable
documentoVersionmaxima
documentoExterno
documentoDescripcion
documentosForFkDocumentoRelacionado
permisoUsuarioDocumentos
procesos
documentosForFkDocumentoRelacionado2
getId ()
setId (DocumentoId id)
getUsuarioByUsuarioRevisorId ()
setUsuarioByUsuarioRevisorId (Usuario us
uarioByUsuarioRevisorId)
getUsuarioByUsuarioCreadorId ()
setUsuarioByUsuarioCreadorId (Usuario us
uarioByUsuarioCreadorId)
getUsuarioByUsuarioAprobadorId ()
setUsuarioByUsuarioAprobadorId (Usuario
usuarioByUsuarioAprobadorId)
getDocumentoNombre ()
setDocumentoNombre (String documentoNomb
re)
getDocumentoArchivo ()
setDocumentoArchivo (byte documentoArchi
vo[])
isDocumentoCreado ()
setDocumentoCreado (boolean documentoCre
ado)
isDocumentoRevisado ()
setDocumentoRevisado (boolean documentoR
evisado)
isDocumentoAprobado ()
setDocumentoAprobado (boolean documentoA
probado)
getDocumentoFechaCreado ()
setDocumentoFechaCreado (Date documentoF
echaCreado)
getDocumentoFechaRevisado ()
setDocumentoFechaRevisado (Date document
oFechaRevisado)
getDocumentoFechaAprobado ()
setDocumentoFechaAprobado (Date document
oFechaAprobado)
isDocumentoGrupoRevision ()
setDocumentoGrupoRevision (boolean docum
entoGrupoRevision)
getDocumentoGrupoAprobacion ()
setDocumentoGrupoAprobacion (Boolean doc
umentoGrupoAprobacion)
getDocumentoTipo ()
setDocumentoTipo (String documentoTipo)
getDocumentoPrioridad ()
setDocumentoPrioridad (short documentoPr
ioridad)
getDocumentoFechaEntrega ()
setDocumentoFechaEntrega (Date documento
FechaEntrega)
isDocumentoVersionable ()
setDocumentoVersionable (boolean documen
toVersionable)
getDocumentoVersionmaxima ()
setDocumentoVersionmaxima (int documento
Versionmaxima)
isDocumentoExterno ()
setDocumentoExterno (boolean documentoEx
terno)
getDocumentoDescripcion ()
setDocumentoDescripcion (String document
oDescripcion)
getDocumentosForFkDocumentoRelacionado (
)
setDocumentosForFkDocumentoRelacionado (
Set documentosForFkDocumentoRelacionado)
getPermisoUsuarioDocumentos ()
setPermisoUsuarioDocumentos (Set permiso
UsuarioDocumentos)
getProcesos ()
setProcesos (Set procesos)
getDocumentosForFkDocumentoRelacionado2
()
setDocumentosForFkDocumentoRelacionado2
(Set documentosForFkDocumentoRelacionado
2)
: DocumentoId
: void
: Usuario
: void
: Usuario
: void
: Usuario
: void
: String
: void
: byte[]
: void
: boolean
: void
: boolean
: void
: boolean
: void
: Date
: void
: Date
: void
: Date
: void
: boolean
: void
: Boolean
: void
: String
: void
: short
: void
: Date
: void
: boolean
: void
: int
: void
: boolean
: void
: String
: void
: Set
: void
: Set
: void
: Set
: void
: Set
: void
Figura 16
Diagrama de clases del paquete com.integraitec.docbpm.business
Descripción
81
Fecha
Autor
18/10/2012
Gustavo Justicia, Lucia Del Pino
5.3.3.2. PAQUETE COM.INTEGRAITEC.DOCBPM.MODELS
82
DocumentoTreeTableNode
<<Unresolved Class>>
DocumentosTreeTableModel
* documento : Documento
* documentos : Documentos
+ <<Constructor>> DocumentoTreeTableNode (Documento valor)
+
getUserObject ()
: Object
+
getValueAt (int column)
: Object
+
setValueAt (Object aValue, int column)
: void
+
validarProcesos ()
: void
+
validarDocumento ()
: void
+ <<Constructor>> DocumentosTreeTableModel (DocumentoTreeT
ableNode nodo, List columnas)
+
getValueAt (Object node, int column)
: Object
DefaultMutableTreeTableNode
(treetable)
<<Unresolved Class>>
DefaultTreeTableModel
(treetable)
<<Unresolved Interface>>
MutableTreeTableNode
(treetable)
ProcesoTreeTableModel
*
*
*
*
*
ProcesoTreeTableNode
*
*
*
*
*
*
proceso
tieneDocumento
tieneProcesosRelacionados
docsRelacionados
procesosRelacionados
relacionadoAproceso
:
:
:
:
:
:
Proceso
boolean
boolean
LinkedList<Documento>
LinkedList<Proceso>
LinkedList<Proceso>
= false
= new LinkedList<>()
= new LinkedList<>()
= new LinkedList<>()
+ <<Constructor>> ProcesoTreeTableNode (Proceso valor)
+
getUserObject ()
+
getValueAt (int column)
+
setValueAt (Object aValue, int column)
+
validarProcesos ()
+
determinarRelacion (Proceso procesoRel,
Set procesosAbuscar)
+
validarDocumento ()
+
getDocumentosProceso ()
+
siTieneDocumento ()
+
getProceso ()
+
getProcesosRelacionados ()
+
getRelacionAprocesos ()
+
getProcesoId ()
+
getProcesoVersion ()
+
setProcesoId (String id)
:
:
:
:
:
Object
Object
void
void
boolean
:
:
:
:
:
:
:
:
:
void
LinkedList
boolean
Proceso
LinkedList
LinkedList
Object
Object
void
modeloEspecial
esDocumento
procesoRelacionado
docRelacionado
documentos
:
:
:
:
:
boolean
boolean
Proceso
Documento
Documentos
= false
= false
= new Documentos()
+ <<Constructor>> ProcesoTreeTableModel (ProcesoTreeTableN
ode nodo, List columnas)
+ <<Constructor>> ProcesoTreeTableModel (ProcesoTreeTableN
ode nodo, List columnas,
Proceso procesoRelacionado)
+ <<Constructor>> ProcesoTreeTableModel (ProcesoTreeTableN
ode nodo, List columnas,
Documento docRelacionado)
+
getValueAt (Object node, int column)
: Object
DefaultListModel_String
EscritorioDialogListModel
+ addElement (String element)
: void
+ populate (String directorioParaSacar) : void
procesoRelacionado
docRelacionado
documento
documentos
<T>
Proceso
(entity)
-
proId
proceso
proNombre
proDescripcion
proNivel
proVersion
proDiagrama
proDiagramaArchivo
documentos
procesos
procesosForProProId
procesosForProId
:
:
:
:
:
:
:
:
:
:
:
:
String
Proceso
String
String
int
int
byte[]
String
Set
Set
Set
Set
=
=
=
=
new HashSet(0)
new HashSet(0)
new HashSet(0)
new HashSet(0)
+ <<Constructor>> Proceso ()
+ <<Constructor>> Proceso (String proId, String proNombre,
int proNivel, int proVersion)
+ <<Constructor>> Proceso (String proId, Proceso proceso,
String proNombre,
String proDescripcion, int proNivel,
int proVersion, byte proDiagrama[],
Set documentos, Set procesos,
Set procesosForProProId,
Set procesosForProId)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Documento
(entity)
DefaultListModel
(swing)
<<bind>>
getProDiagramaArchivo ()
setProDiagramaArchivo (String proDiagram
aArchivo)
getProId ()
setProId (String proId)
getProceso ()
setProceso (Proceso proceso)
getProNombre ()
setProNombre (String proNombre)
getProDescripcion ()
setProDescripcion (String proDescripcion
)
getProNivel ()
setProNivel (int proNivel)
getProVersion ()
setProVersion (int proVersion)
getProDiagrama ()
setProDiagrama (byte proDiagrama[])
getDocumentos ()
setDocumentos (Set documentos)
getProcesos ()
setProcesos (Set procesos)
getProcesosForProProId ()
setProcesosForProProId (Set procesosForP
roProId)
getProcesosForProId ()
setProcesosForProId (Set procesosForProI
d)
: String
: void
:
:
:
:
:
:
:
:
String
void
Proceso
void
String
void
String
void
:
:
:
:
:
:
:
:
:
:
:
:
int
void
int
void
byte[]
void
Set
void
Set
void
Set
void
: Set
: void
proceso
-
id
usuarioByUsuarioRevisorId
usuarioByUsuarioCreadorId
usuarioByUsuarioAprobadorId
documentoNombre
documentoArchivo
documentoCreado
documentoRevisado
documentoAprobado
documentoFechaCreado
documentoFechaRevisado
documentoFechaAprobado
documentoGrupoRevision
documentoGrupoAprobacion
documentoTipo
documentoPrioridad
documentoFechaEntrega
documentoVersionable
documentoVersionmaxima
documentoExterno
documentoDescripcion
documentosForFkDocumentoRelacionado
permisoUsuarioDocumentos
procesos
documentosForFkDocumentoRelacionado2
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
DocumentoId
Usuario
Usuario
Usuario
String
byte[]
boolean
boolean
boolean
Date
Date
Date
boolean
Boolean
String
short
Date
boolean
int
boolean
String
Set
Set
Set
Set
Documentos
(business)
*
*
*
*
*
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
+ <<Constructor>> Documento ()
+ <<Constructor>> Documento (DocumentoId id,
String documentoNombre,
boolean documentoCreado,
boolean documentoRevisado,
boolean documentoAprobado,
boolean documentoGrupoRevision,
String documentoTipo,
short documentoPrioridad,
Date documentoFechaEntrega,
boolean documentoVersionable,
int documentoVersionmaxima,
boolean documentoExterno)
+ <<Constructor>> Documento (DocumentoId id,
Usuario usuarioByUsuarioRevisorId,
Usuario usuarioByUsuarioCreadorId,
Usuario usuarioByUsuarioAprobadorId,
String documentoNombre,
byte documentoArchivo[],
boolean documentoCreado,
boolean documentoRevisado,
boolean documentoAprobado,
Date documentoFechaCreado,
Date documentoFechaRevisado,
Date documentoFechaAprobado,
boolean documentoGrupoRevision,
Boolean documentoGrupoAprobacion,
String documentoTipo,
short documentoPrioridad,
Date documentoFechaEntrega,
boolean documentoVersionable,
int documentoVersionmaxima,
boolean documentoExterno,
String documentoDescripcion,
Set documentosForFkDocumentoRelacionado
, Set permisoUsuarioDocumentos,
Set procesos,
Set documentosForFkDocumentoRelacionado
2)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
getId ()
setId (DocumentoId id)
getUsuarioByUsuarioRevisorId ()
setUsuarioByUsuarioRevisorId (Usuario us
uarioByUsuarioRevisorId)
getUsuarioByUsuarioCreadorId ()
setUsuarioByUsuarioCreadorId (Usuario us
uarioByUsuarioCreadorId)
getUsuarioByUsuarioAprobadorId ()
setUsuarioByUsuarioAprobadorId (Usuario
usuarioByUsuarioAprobadorId)
getDocumentoNombre ()
setDocumentoNombre (String documentoNomb
re)
getDocumentoArchivo ()
setDocumentoArchivo (byte documentoArchi
vo[])
isDocumentoCreado ()
setDocumentoCreado (boolean documentoCre
ado)
isDocumentoRevisado ()
setDocumentoRevisado (boolean documentoR
evisado)
isDocumentoAprobado ()
setDocumentoAprobado (boolean documentoA
probado)
getDocumentoFechaCreado ()
setDocumentoFechaCreado (Date documentoF
echaCreado)
getDocumentoFechaRevisado ()
setDocumentoFechaRevisado (Date document
oFechaRevisado)
getDocumentoFechaAprobado ()
setDocumentoFechaAprobado (Date document
oFechaAprobado)
isDocumentoGrupoRevision ()
setDocumentoGrupoRevision (boolean docum
entoGrupoRevision)
getDocumentoGrupoAprobacion ()
setDocumentoGrupoAprobacion (Boolean doc
umentoGrupoAprobacion)
getDocumentoTipo ()
setDocumentoTipo (String documentoTipo)
getDocumentoPrioridad ()
setDocumentoPrioridad (short documentoPr
ioridad)
getDocumentoFechaEntrega ()
setDocumentoFechaEntrega (Date documento
FechaEntrega)
isDocumentoVersionable ()
setDocumentoVersionable (boolean documen
toVersionable)
getDocumentoVersionmaxima ()
setDocumentoVersionmaxima (int documento
Versionmaxima)
isDocumentoExterno ()
setDocumentoExterno (boolean documentoEx
terno)
getDocumentoDescripcion ()
setDocumentoDescripcion (String document
oDescripcion)
getDocumentosForFkDocumentoRelacionado (
)
setDocumentosForFkDocumentoRelacionado (
Set documentosForFkDocumentoRelacionado)
getPermisoUsuarioDocumentos ()
setPermisoUsuarioDocumentos (Set permiso
UsuarioDocumentos)
getProcesos ()
setProcesos (Set procesos)
getDocumentosForFkDocumentoRelacionado2
()
setDocumentosForFkDocumentoRelacionado2
(Set documentosForFkDocumentoRelacionado
2)
Titulo
Descripción
usuarioConectado
documentosLista
modelo
nodos
sesionAbierta
sesionAux
:
:
:
:
:
:
Usuario
List<Documento>
DocumentosTreeTableModel
LinkedList<DocumentoTreeTableNode>
Session
Session
+ getModelo ()
+ setModelo (DocumentosTreeTableModel mode
lo)
+ crearSesion ()
+ abrirSesion ()
+ cerrarSesion ()
+ asignarPermisoDocumento (Usuario usuario
, Documento doc)
+ getDocumentoByID (String id,
String version)
+ getDocumentoByIDSesionAbierta (String id
, String version)
+ getContaDocumentosPorId (String id)
+ getContaDocumentos ()
+ getContaDocumentosNuevos ()
+ cargarDocsAprobarPorUsuario (Usuario usu
arioC)
+ cargarDocsRevisarPorUsuario (Usuario usu
arioC)
+ cargarDocsCrearPorUsuario (Usuario usuar
ioC)
+ cargarDocsLMD (Usuario usuarioC)
+ crearModelo ()
+ crearIdentificadoresArbol ()
+ generarModelo (List identificadores)
+ generarNodo (Documento valor)
+ cargarArbolDeDocumentosAprobados ()
+ setDocumentoFile (byte documento[],
Documento documentoAguardar)
+ guardarDocumento (Documento documento)
+ setProcesosRelacioados (Set procesosArel
acionar, Documento documento)
+ tipoDocumentoPorExtension (String extens
ion)
- insertarDocumentoArbol (DocumentoTreeTab
leNode padre,
DocumentoTreeTableNode hijo)
+ setUsuarioDefault (Usuario usuarioConect
ado)
+ revocarPermisoDocumento (Usuario next,
Documento documento)
+ removerProcesosRelacioados (HashSet proc
esosRelacionados, Documento documento)
= new LinkedList<DocumentoTreeTableNode>()
: DocumentosTreeTableModel
: void
: void
: void
: void
: void
: Documento
: Documento
: int
: int
: int
: DefaultTableModel
: DefaultTableModel
: DefaultTableModel
:
:
:
:
:
:
:
DefaultTableModel
void
List
DocumentosTreeTableModel
DocumentoTreeTableNode
void
void
: void
: void
: String
: void
: void
: void
: void
AccionDocumentoRevisar
AccionDocumentoAprobar
AccionDocumentoSubir
: DocumentoId
: void
: Usuario
: void
: Usuario
: void
: Usuario
: void
: String
: void
: byte[]
: void
: boolean
: void
: boolean
: void
: boolean
: void
: Date
: void
: Date
: void
: Date
: void
: boolean
: void
: Boolean
: void
: String
: void
: short
: void
: Date
: void
: boolean
: void
: int
: void
: boolean
: void
: String
: void
: Set
: void
: Set
: void
: Set
: void
: Set
: void
Figura 17
Diagrama de clases del paquete
83
COM.INTEGRAITEC.DOCBPM.MODELS
18/10/2012
Fecha
Autor/Fuente Gustavo Justicia, Lucia Del Pino
5.3.3.3. PAQUETE COM.INTEGRAITEC.DOCBPM.ENTITY
84
Opcion
- opcionId
: short
- opcionNombre : String
- perfils
: Set
= new HashSet(0)
+ <<Constructor>> Opcion ()
+ <<Constructor>> Opcion (short opcionId,
String opcionNombre)
+ <<Constructor>> Opcion (short opcionId,
String opcionNombre, Set perfils)
+
getOpcionId ()
+
setOpcionId (short opcionId)
+
getOpcionNombre ()
+
setOpcionNombre (String opcionNombre)
+
getPerfils ()
+
setPerfils (Set perfils)
Perfil
- perfilId
: short
- perfilNombre
: String
- perfilDescripcion : String
- opcions
: Set
- usuarios
: Set
Permiso
- permisoId
: String
- permisoTipo
: String
- permisoDescripcion
: String
- permisoUsuarioDocumentos : Set
= new HashSet(0)
+ <<Constructor>> Permiso ()
+ <<Constructor>> Permiso (String permisoId,
String permisoTipo)
+ <<Constructor>> Permiso (String permisoId,
String permisoTipo,
String permisoDescripcion,
Set permisoUsuarioDocumentos)
+
+
+
+
+
+
getPermisoId ()
setPermisoId (String permisoId)
getPermisoTipo ()
setPermisoTipo (String permisoTipo)
getPermisoDescripcion ()
setPermisoDescripcion (String permisoDes
cripcion)
getPermisoUsuarioDocumentos ()
setPermisoUsuarioDocumentos (Set permiso
UsuarioDocumentos)
+
+
Documento
-
= new HashSet(0)
= new HashSet(0)
+ <<Constructor>> Perfil ()
+ <<Constructor>> Perfil (short perfilId,
String perfilNombre,
String perfilDescripcion)
+ <<Constructor>> Perfil (short perfilId,
String perfilNombre,
String perfilDescripcion, Set opcions,
Set usuarios)
+
+
+
+
+
+
permiso
: String
: void
: String
: void
: String
: void
getPerfilId ()
setPerfilId (short perfilId)
getPerfilNombre ()
setPerfilNombre (String perfilNombre)
getPerfilDescripcion ()
setPerfilDescripcion (String perfilDescr
ipcion)
getOpcions ()
setOpcions (Set opcions)
getUsuarios ()
setUsuarios (Set usuarios)
+
+
+
+
: Set
: void
: short
: void
: String
: void
: String
: void
: Set
: void
: Set
: void
perfil
-
usuarioId
perfil
grupo
usuarioNick
usuarioPassword
usuarioNombre
usuarioApellido
usuarioCargo
usuarioFechaCreacion
usuarioFechaInactivacion
usuarioActivo
usuarioSuperUsuario
usuarioPkey
usuarioFirma
documentosForUsuarioAprobadorId
documentosForUsuarioRevisorId
cuentas
permisoUsuarioDocumentos
documentosForUsuarioCreadorId
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
int
Perfil
Grupo
String
String
String
String
String
Date
Date
boolean
boolean
byte[]
String
Set
Set
Set
Set
Set
-
:
:
:
:
:
:
:
:
:
:
:
:
:
:
String
Usuario
String
String
String
boolean
boolean
String
boolean
String
String
boolean
Date
Date
usuario
+ <<Constructor>> Cuenta ()
+ <<Constructor>> Cuenta (String cuentaId,
Usuario usuario, String cuentaEmail,
String cuentaSmtp,
String cuentaEntrada,
boolean cuentaImap, boolean cuentaSsl,
String cuentaPassword,
boolean cuentaDefault,
String cuentaPuertoSmtp,
String cuentaPuertoEntrada,
boolean cuentaActiva,
Date cuentaFechaCreacion)
+
+
+
+
+
+
+
+
+ <<Constructor>> Cuenta (String cuentaId,
Usuario usuario, String cuentaEmail,
String cuentaSmtp,
String cuentaEntrada,
boolean cuentaImap, boolean cuentaSsl,
String cuentaPassword,
boolean cuentaDefault,
String cuentaPuertoSmtp,
String cuentaPuertoEntrada,
boolean cuentaActiva,
Date cuentaFechaCreacion,
Date cuentaFechaInactivacion)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
getCuentaId ()
setCuentaId (String cuentaId)
getUsuario ()
setUsuario (Usuario usuario)
getCuentaEmail ()
setCuentaEmail (String cuentaEmail)
getCuentaSmtp ()
setCuentaSmtp (String cuentaSmtp)
getCuentaEntrada ()
setCuentaEntrada (String cuentaEntrada)
isCuentaImap ()
setCuentaImap (boolean cuentaImap)
isCuentaSsl ()
setCuentaSsl (boolean cuentaSsl)
getCuentaPassword ()
setCuentaPassword (String cuentaPassword
)
isCuentaDefault ()
setCuentaDefault (boolean cuentaDefault)
getCuentaPuertoSmtp ()
setCuentaPuertoSmtp (String cuentaPuerto
Smtp)
getCuentaPuertoEntrada ()
setCuentaPuertoEntrada (String cuentaPue
rtoEntrada)
isCuentaActiva ()
setCuentaActiva (boolean cuentaActiva)
getCuentaFechaCreacion ()
setCuentaFechaCreacion (Date cuentaFecha
Creacion)
getCuentaFechaInactivacion ()
setCuentaFechaInactivacion (Date cuentaF
echaInactivacion)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
+
+
+
+
+
+
String
void
Usuario
void
String
void
String
void
String
void
boolean
void
boolean
void
String
void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
getUsuarioId ()
setUsuarioId (int usuarioId)
getPerfil ()
setPerfil (Perfil perfil)
getGrupo ()
setGrupo (Grupo grupo)
getUsuarioNick ()
setUsuarioNick (String usuarioNick)
getUsuarioPassword ()
setUsuarioPassword (String usuarioPasswo
rd)
getUsuarioNombre ()
setUsuarioNombre (String usuarioNombre)
getUsuarioApellido ()
setUsuarioApellido (String usuarioApelli
do)
getUsuarioCargo ()
setUsuarioCargo (String usuarioCargo)
getUsuarioFechaCreacion ()
setUsuarioFechaCreacion (Date usuarioFec
haCreacion)
getUsuarioFechaInactivacion ()
setUsuarioFechaInactivacion (Date usuari
oFechaInactivacion)
isUsuarioActivo ()
setUsuarioActivo (boolean usuarioActivo)
isUsuarioSuperUsuario ()
setUsuarioSuperUsuario (boolean usuarioS
uperUsuario)
getUsuarioPkey ()
setUsuarioPkey (byte usuarioPkey[])
getUsuarioFirma ()
setUsuarioFirma (String usuarioFirma)
getDocumentosForUsuarioAprobadorId ()
setDocumentosForUsuarioAprobadorId (Set
documentosForUsuarioAprobadorId)
getDocumentosForUsuarioRevisorId ()
setDocumentosForUsuarioRevisorId (Set do
cumentosForUsuarioRevisorId)
getCuentas ()
setCuentas (Set cuentas)
getPermisoUsuarioDocumentos ()
setPermisoUsuarioDocumentos (Set permiso
UsuarioDocumentos)
getDocumentosForUsuarioCreadorId ()
setDocumentosForUsuarioCreadorId (Set do
cumentosForUsuarioCreadorId)
: boolean
: void
: String
: void
getPudId ()
setPudId (String pudId)
getUsuario ()
setUsuario (Usuario usuario)
getPermiso ()
setPermiso (Permiso permiso)
getDocumento ()
setDocumento (Documento documento)
getPudFechaInstauracion ()
setPudFechaInstauracion (Date pudFechaIn
stauracion)
getPudFechaValidez ()
setPudFechaValidez (Date pudFechaValidez
)
: Date
: void
+
+
+
+
documento
:
:
:
:
:
:
:
:
:
:
int
void
Perfil
void
Grupo
void
String
void
String
void
+
+
+
+
+
+
+
+
: String
: void
: String
: void
+
+
+
+
: String
: void
: Date
: void
+
+
: Set
: void
: Set
: void
: Set
: void
: Set
: void
Grupo
- grupoId
: int
- grupoNombre : String
- usuarios
: Set
: boolean
: void
: Date
: void
+ <<Constructor>> Grupo ()
+ <<Constructor>> Grupo (int grupoId, String grupoNombre)
+ <<Constructor>> Grupo (int grupoId, String grupoNombre,
Set usuarios)
+
getGrupoId ()
: int
+
setGrupoId (int grupoId)
: void
+
getGrupoNombre ()
: String
+
setGrupoNombre (String grupoNombre) : void
+
getUsuarios ()
: Set
+
setUsuarios (Set usuarios)
: void
= new HashSet(0)
+
+
Proceso
: boolean
: void
: boolean
: void
: byte[]
: void
: String
: void
: Set
: void
+
+
+
+
usuarioByUsuarioCreadorId
usuario
usuarioByUsuarioAprobadorId
usuarioByUsuarioRevisorId
: Date
: void
proceso
-
proId
proceso
proNombre
proDescripcion
proNivel
proVersion
proDiagrama
proDiagramaArchivo
documentos
procesos
procesosForProProId
procesosForProId
:
:
:
:
:
:
:
:
:
:
:
:
String
Proceso
String
String
int
int
byte[]
String
Set
Set
Set
Set
+
+
+
+
+
+
+
+
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
+
+
+ <<Constructor>> Proceso ()
+ <<Constructor>> Proceso (String proId, String proNombre,
int proNivel, int proVersion)
+ <<Constructor>> Proceso (String proId, Proceso proceso,
String proNombre,
String proDescripcion, int proNivel,
int proVersion, byte proDiagrama[],
Set documentos, Set procesos,
Set procesosForProProId,
Set procesosForProId)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
getProDiagramaArchivo ()
setProDiagramaArchivo (String proDiagram
aArchivo)
getProId ()
setProId (String proId)
getProceso ()
setProceso (Proceso proceso)
getProNombre ()
setProNombre (String proNombre)
getProDescripcion ()
setProDescripcion (String proDescripcion
)
getProNivel ()
setProNivel (int proNivel)
getProVersion ()
setProVersion (int proVersion)
getProDiagrama ()
setProDiagrama (byte proDiagrama[])
getDocumentos ()
setDocumentos (Set documentos)
getProcesos ()
setProcesos (Set procesos)
getProcesosForProProId ()
setProcesosForProProId (Set procesosForP
roProId)
getProcesosForProId ()
setProcesosForProId (Set procesosForProI
d)
DocumentoId
Usuario
Usuario
Usuario
String
byte[]
boolean
boolean
boolean
Date
Date
Date
boolean
Boolean
String
short
Date
boolean
int
boolean
String
Set
Set
Set
Set
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
+ <<Constructor>> Documento (DocumentoId id,
Usuario usuarioByUsuarioRevisorId,
Usuario usuarioByUsuarioCreadorId,
Usuario usuarioByUsuarioAprobadorId,
String documentoNombre,
byte documentoArchivo[],
boolean documentoCreado,
boolean documentoRevisado,
boolean documentoAprobado,
Date documentoFechaCreado,
Date documentoFechaRevisado,
Date documentoFechaAprobado,
boolean documentoGrupoRevision,
Boolean documentoGrupoAprobacion,
String documentoTipo,
short documentoPrioridad,
Date documentoFechaEntrega,
boolean documentoVersionable,
int documentoVersionmaxima,
boolean documentoExterno,
String documentoDescripcion,
Set documentosForFkDocumentoRelacionado
, Set permisoUsuarioDocumentos,
Set procesos,
Set documentosForFkDocumentoRelacionado
2)
String
void
Usuario
void
Permiso
void
Documento
void
Date
void
Serializable
(io)
: String
: void
Titulo
Descripción
Fecha
Autor/Fuente
:
:
:
:
:
:
:
:
:
:
<<Unresolved Interface>>
grupo
: Date
: void
String
Usuario
Permiso
Documento
Date
Date
+ <<Constructor>> PermisoUsuarioDocumento (String pudId,
Usuario usuario, Permiso permiso,
Documento documento,
Date pudFechaInstauracion,
Date pudFechaValidez)
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
+ <<Constructor>> Usuario (int usuarioId, Perfil perfil,
Grupo grupo, String usuarioNick,
String usuarioPassword,
String usuarioNombre,
String usuarioApellido,
String usuarioCargo,
Date usuarioFechaCreacion,
Date usuarioFechaInactivacion,
boolean usuarioActivo,
boolean usuarioSuperUsuario,
byte usuarioPkey[],
String usuarioFirma,
Set documentosForUsuarioAprobadorId,
Set documentosForUsuarioRevisorId,
Set cuentas,
Set permisoUsuarioDocumentos,
Set documentosForUsuarioCreadorId)
Cuenta
cuentaId
usuario
cuentaEmail
cuentaSmtp
cuentaEntrada
cuentaImap
cuentaSsl
cuentaPassword
cuentaDefault
cuentaPuertoSmtp
cuentaPuertoEntrada
cuentaActiva
cuentaFechaCreacion
cuentaFechaInactivacion
:
:
:
:
:
:
+ <<Constructor>> PermisoUsuarioDocumento ()
+ <<Constructor>> PermisoUsuarioDocumento (String pudId,
Usuario usuario, Permiso permiso,
Date pudFechaInstauracion,
Date pudFechaValidez)
+ <<Constructor>> Usuario ()
+ <<Constructor>> Usuario (int usuarioId, Perfil perfil,
Grupo grupo, String usuarioNick,
String usuarioPassword,
String usuarioNombre,
String usuarioApellido,
String usuarioCargo,
Date usuarioFechaCreacion,
boolean usuarioActivo,
boolean usuarioSuperUsuario)
-
pudId
usuario
permiso
documento
pudFechaInstauracion
pudFechaValidez
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
+ <<Constructor>> Documento ()
+ <<Constructor>> Documento (DocumentoId id,
String documentoNombre,
boolean documentoCreado,
boolean documentoRevisado,
boolean documentoAprobado,
boolean documentoGrupoRevision,
String documentoTipo,
short documentoPrioridad,
Date documentoFechaEntrega,
boolean documentoVersionable,
int documentoVersionmaxima,
boolean documentoExterno)
PermisoUsuarioDocumento
Usuario
id
usuarioByUsuarioRevisorId
usuarioByUsuarioCreadorId
usuarioByUsuarioAprobadorId
documentoNombre
documentoArchivo
documentoCreado
documentoRevisado
documentoAprobado
documentoFechaCreado
documentoFechaRevisado
documentoFechaAprobado
documentoGrupoRevision
documentoGrupoAprobacion
documentoTipo
documentoPrioridad
documentoFechaEntrega
documentoVersionable
documentoVersionmaxima
documentoExterno
documentoDescripcion
documentosForFkDocumentoRelacionado
permisoUsuarioDocumentos
procesos
documentosForFkDocumentoRelacionado2
+
+
+
+
+
+
: String
: void
:
:
:
:
:
:
:
:
String
void
Proceso
void
String
void
String
void
:
:
:
:
:
:
:
:
:
:
:
:
int
void
int
void
byte[]
void
Set
void
Set
void
Set
void
+
+
+
+
id
+
+
DocumentoId
- documentoId
: String
- documentoVersion : int
+ <<Constructor>> DocumentoId ()
+ <<Constructor>> DocumentoId (String documentoId,
int documentoVersion)
+
getDocumentoId ()
+
setDocumentoId (String documentoId)
+
getDocumentoVersion ()
+
setDocumentoVersion (int documentoVersio
n)
+
equals (Object other)
+
hashCode ()
+
+
+
+
: String
: void
: int
: void
getId ()
setId (DocumentoId id)
getUsuarioByUsuarioRevisorId ()
setUsuarioByUsuarioRevisorId (Usuario us
uarioByUsuarioRevisorId)
getUsuarioByUsuarioCreadorId ()
setUsuarioByUsuarioCreadorId (Usuario us
uarioByUsuarioCreadorId)
getUsuarioByUsuarioAprobadorId ()
setUsuarioByUsuarioAprobadorId (Usuario
usuarioByUsuarioAprobadorId)
getDocumentoNombre ()
setDocumentoNombre (String documentoNomb
re)
getDocumentoArchivo ()
setDocumentoArchivo (byte documentoArchi
vo[])
isDocumentoCreado ()
setDocumentoCreado (boolean documentoCre
ado)
isDocumentoRevisado ()
setDocumentoRevisado (boolean documentoR
evisado)
isDocumentoAprobado ()
setDocumentoAprobado (boolean documentoA
probado)
getDocumentoFechaCreado ()
setDocumentoFechaCreado (Date documentoF
echaCreado)
getDocumentoFechaRevisado ()
setDocumentoFechaRevisado (Date document
oFechaRevisado)
getDocumentoFechaAprobado ()
setDocumentoFechaAprobado (Date document
oFechaAprobado)
isDocumentoGrupoRevision ()
setDocumentoGrupoRevision (boolean docum
entoGrupoRevision)
getDocumentoGrupoAprobacion ()
setDocumentoGrupoAprobacion (Boolean doc
umentoGrupoAprobacion)
getDocumentoTipo ()
setDocumentoTipo (String documentoTipo)
getDocumentoPrioridad ()
setDocumentoPrioridad (short documentoPr
ioridad)
getDocumentoFechaEntrega ()
setDocumentoFechaEntrega (Date documento
FechaEntrega)
isDocumentoVersionable ()
setDocumentoVersionable (boolean documen
toVersionable)
getDocumentoVersionmaxima ()
setDocumentoVersionmaxima (int documento
Versionmaxima)
isDocumentoExterno ()
setDocumentoExterno (boolean documentoEx
terno)
getDocumentoDescripcion ()
setDocumentoDescripcion (String document
oDescripcion)
getDocumentosForFkDocumentoRelacionado (
)
setDocumentosForFkDocumentoRelacionado (
Set documentosForFkDocumentoRelacionado)
getPermisoUsuarioDocumentos ()
setPermisoUsuarioDocumentos (Set permiso
UsuarioDocumentos)
getProcesos ()
setProcesos (Set procesos)
getDocumentosForFkDocumentoRelacionado2
()
setDocumentosForFkDocumentoRelacionado2
(Set documentosForFkDocumentoRelacionado
2)
: DocumentoId
: void
: Usuario
: void
: Usuario
: void
: Usuario
: void
: String
: void
: byte[]
: void
: boolean
: void
: boolean
: void
: boolean
: void
: Date
: void
: Date
: void
: Date
: void
: boolean
: void
: Boolean
: void
: String
: void
: short
: void
: Date
: void
: boolean
: void
: int
: void
: boolean
: void
: String
: void
: Set
: void
: Set
: void
: Set
: void
: Set
: void
: boolean
: int
: Set
: void
Figura 18
Diagrama del paquete com.integraitec.docbpm.entity
18/10/2012
Gustavo Justicia, Lucia Del Pino
5.3.3.4. PAQUETE COM.INTEGRAITEC.DOCBPM.VISUAL
85
:
:
:
:
:
:
short
void
String
void
Set
void
DocumentosInternalFrame
* cuentas : Cuentas
+
notificarSolicitudCreacionDocumento (Usu
ario solicitante, Usuario notificado,
String documento, String nota)
notificarSolicitudPerfilesUsuarios (Usua
rio solicitante, Usuario notificado,
String usuarioCambio, String nota,
int tipo)
+
+
+
= new LinkedList<DocumentoTreeTableNode>()
+ getModelo ()
+ setModelo (DocumentosTreeTableModel mode
lo)
+ crearSesion ()
+ abrirSesion ()
+ cerrarSesion ()
+ asignarPermisoDocumento (Usuario usuario
, Documento doc)
+ getDocumentoByID (String id,
String version)
+ getDocumentoByIDSesionAbierta (String id
, String version)
+ getContaDocumentosPorId (String id)
+ getContaDocumentos ()
+ getContaDocumentosNuevos ()
+ cargarDocsAprobarPorUsuario (Usuario usu
arioC)
+ cargarDocsRevisarPorUsuario (Usuario usu
arioC)
+ cargarDocsCrearPorUsuario (Usuario usuar
ioC)
+ cargarDocsLMD (Usuario usuarioC)
+ crearModelo ()
+ crearIdentificadoresArbol ()
+ generarModelo (List identificadores)
+ generarNodo (Documento valor)
+ cargarArbolDeDocumentosAprobados ()
+ setDocumentoFile (byte documento[],
Documento documentoAguardar)
+ guardarDocumento (Documento documento)
+ setProcesosRelacioados (Set procesosArel
acionar, Documento documento)
+ tipoDocumentoPorExtension (String extens
ion)
- insertarDocumentoArbol (DocumentoTreeTab
leNode padre,
DocumentoTreeTableNode hijo)
: DocumentosTreeTableModel
: void
+ setUsuarioDefault (Usuario usuarioConect
ado)
+ revocarPermisoDocumento (Usuario next,
Documento documento)
+ removerProcesosRelacioados (HashSet proc
esosRelacionados, Documento documento)
: void
Usuarios
Grupos
Documento
Documentos
boolean
int
int
javax.swing.JButton
javax.swing.JButton
javax.swing.JList
javax.swing.JScrollPane
javax.swing.JButton
javax.swing.JCheckBox
javax.swing.JList
org.jdesktop.swingx.JXTitledSeparator
javax.swing.JScrollPane
: Documento
-
-
documentos
: DefaultTableModel
: DefaultTableModel
: void
: List
: DocumentosTreeTableModel
: DocumentoTreeTableNode
: void
: void
: void
: void
: String
: void
= new Perfiles()
perfil
perfil
utilidadesPerfiles
perfiles
: void
: void
: void
: void
: void
: void
: boolean
parent
utilidadesUsuarios
utilidadesGrupos
utilidadesPerfiles
primeraGrupos
actualizarPerfiles
actualizarTabla
actualizarTablaUsuarios
busquedaUsuarios
crearPerfil
crearU
crearUsuario
editarGrupo
editarPerfiles
editarUsuario
eliimnar
eliminarUsuario
gruposTab
paneGrupos
panePerfiles
paneUsuario
paneUsuarios
panelGeneral
panelPerfiles
panelUsuarios
tablaGrupos
tablaPerfiles
tablaUsuarios
tabsEdicion
usuariosCredTitlePane
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
MainFrame
Usuarios
Grupos
Perfiles
boolean
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
org.jdesktop.swingx.JXSearchField
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JPanel
org.jdesktop.swingx.JXSearchField
javax.swing.JScrollPane
javax.swing.JScrollPane
javax.swing.JScrollPane
javax.swing.JPanel
javax.swing.JPanel
javax.swing.JPanel
org.jdesktop.swingx.JXTable
org.jdesktop.swingx.JXTable
org.jdesktop.swingx.JXTable
javax.swing.JTabbedPane
javax.swing.JLabel
id
usuarioByUsuarioRevisorId
usuarioByUsuarioCreadorId
usuarioByUsuarioAprobadorId
documentoNombre
documentoArchivo
documentoCreado
documentoRevisado
documentoAprobado
documentoFechaCreado
documentoFechaRevisado
documentoFechaAprobado
documentoGrupoRevision
documentoGrupoAprobacion
documentoTipo
documentoPrioridad
documentoFechaEntrega
documentoVersionable
documentoVersionmaxima
documentoExterno
documentoDescripcion
documentosForFkDocumentoRelacionado
permisoUsuarioDocumentos
procesos
documentosForFkDocumentoRelacionado2
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
DocumentoId
Usuario
Usuario
Usuario
String
byte[]
boolean
boolean
boolean
Date
Date
Date
boolean
Boolean
String
short
Date
boolean
int
boolean
String
Set
Set
Set
Set
= true
+ <<Constructor>> UsuariosFrame (MainFrame parent)
cerrarFrame ()
initComponents ()
crearUsuarioActionPerformed (java.awt.
event.ActionEvent evt)
editarUsuarioActionPerformed (java.awt.
event.ActionEvent evt)
panelUsuariosComponentShown (java.awt.
event.ComponentEvent evt)
panelUsuariosFocusGained (java.awt.
event.FocusEvent evt)
panelUsuariosMouseEntered (java.awt.
event.MouseEvent evt)
actualizarTablaUsuariosActionPerformed (
java.awt.event.ActionEvent evt)
gruposTabComponentShown (java.awt.event.
ComponentEvent evt)
crearUActionPerformed (java.awt.event.
ActionEvent evt)
editarGrupoActionPerformed (java.awt.
event.ActionEvent evt)
actualizarTablaActionPerformed (java.
awt.event.ActionEvent evt)
tablaUsuariosMouseClicked (java.awt.
event.MouseEvent evt)
busquedaUsuariosKeyTyped (java.awt.
event.KeyEvent evt)
paneGruposKeyTyped (java.awt.event.
KeyEvent evt)
paneGruposKeyPressed (java.awt.event.
KeyEvent evt)
busquedaUsuariosKeyPressed (java.awt.
event.KeyEvent evt)
tablaGruposMouseClicked (java.awt.event.
MouseEvent evt)
panelPerfilesComponentShown (java.awt.
event.ComponentEvent evt)
actualizarPerfilesActionPerformed (java.
awt.event.ActionEvent evt)
tablaPerfilesMouseClicked (java.awt.
event.MouseEvent evt)
editarPerfilesActionPerformed (java.awt.
event.ActionEvent evt)
utilidadPerfils
crearPerfilActionPerformed (java.awt.
event.ActionEvent evt)
refrescarTablaUsuarios ()
refrescarTablaGrupos ()
refrescarTablaPerfiles ()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
: void
: void
: void
+
+
: void
+
+
: void
+
+
: void
+
+
: void
: void
+
+
: void
+
+
: void
: void
+
+
+
+
: void
: void
+
+
: void
: void
PerfilesDialog
*
*
-
: void
: void
: void
: void
: void
: void
perfil
utilidadPerfils
cancelar
descLabel
descripcionPerfil
editarOpciones
guardar
jScrollPane1
labelOpciones
nombrePerfil
perfilLabel
:
:
:
:
:
:
:
:
:
:
:
Perfil
Perfiles
javax.swing.JButton
javax.swing.JLabel
javax.swing.JTextArea
javax.swing.JButton
javax.swing.JButton
javax.swing.JScrollPane
javax.swing.JLabel
javax.swing.JTextField
javax.swing.JLabel
+
+
= new Perfiles()
+
+
+
+
+
+
+ <<Constructor>> PerfilesDialog (java.awt.Frame parent,
boolean modal)
+ <<Constructor>> PerfilesDialog (java.awt.Frame parent,
boolean modal, Perfil perfil)
+
llenarCampos ()
: void
initComponents ()
: void
cancelarActionPerformed (java.awt.event. : void
ActionEvent evt)
guardarActionPerformed (java.awt.event. : void
ActionEvent evt)
editarOpcionesActionPerformed (java.awt. : void
event.ActionEvent evt)
+
main (String args[])
: void
: void
: void
: void
: void
: void
+
+
+
+
+
+
+
+
- busquedaAprobados
: org.jdesktop.swingx.JXSearchField
- docsPorAprobarSeparador : org.jdesktop.swingx.JXTitledSeparator
- paneAprobados
: javax.swing.JScrollPane
- tablaAprobados
: org.jdesktop.swingx.JXTable
documentosPorRevisarPanel1
documentosPorAprobarPanel1
+ <<Constructor>> DocumentosPorAprobarPanel ()
+
getTablaAprobados ()
: JXTable
+
getTablaAprobados (JXTable jXTable1) : void
initComponents ()
: void
*
*
*
*
*
*
*
*
*
*
+
+
+
*
-
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
UsuariosDelGrupoDialog
*
*
*
+
+
-
grupos
usuarios
grupo
CONSULTA
ADMINISTRACION
cancelarBoton
guardarBoton
jButton3
pasarDer
pasarIzq
uSistemaScroll
ugrupoScroll
usuariosGrupoPanel
usuariosSistemaPanel
:
:
:
:
:
:
:
:
:
:
:
:
:
:
Grupos
Usuarios
Grupo
short
short
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JScrollPane
javax.swing.JScrollPane
javax.swing.JList
javax.swing.JList
= new Grupos()
= new Usuarios()
=1
=2
-
usuarios
solicitante
grupos
grupoSeleccionado
notificaciones
documentos
selgrupo
esCreacion
nota
docNombre
CREACION_USUARIO
MODIFICACION_USUARIO
BAJA_USUARIO
tipo
GruposUsuariosSeparator
aceptarBoton
lstaSolicitud
ugruposPane
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
Usuarios
Usuario
Grupos
Grupo
Notificaciones
Documentos
boolean
boolean
String
String
int
int
int
int
org.jdesktop.swingx.JXTitledSeparator
javax.swing.JButton
javax.swing.JList
javax.swing.JScrollPane
= new Usuarios()
= new Notificaciones()
= new Documentos()
= false
= false
-
initComponents ()
: void
pasarIzqActionPerformed (java.awt.event. : void
ActionEvent evt)
pasarDerActionPerformed (java.awt.event. : void
ActionEvent evt)
cancelarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
guardarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
GruposDialog
* grupo
: Grupo
* utilidadGrupos : Grupos
- cancelar
: javax.swing.JButton
- guardar
: javax.swing.JButton
- nombreGrupo : javax.swing.JTextField
- nombreLabel : javax.swing.JLabel
- usuarioGrupo : javax.swing.JButton
= new Grupos()
+ <<Constructor>> GruposDialog (java.awt.Frame parent,
boolean modal)
+ <<Constructor>> GruposDialog (java.awt.Frame parent,
boolean modal, Grupo grupo)
+
llenarCampos ()
: void
initComponents ()
: void
guardarActionPerformed (java.awt.event. : void
ActionEvent evt)
cancelarActionPerformed (java.awt.event. : void
ActionEvent evt)
usuarioGrupoActionPerformed (java.awt. : void
event.ActionEvent evt)
+
main (String args[])
: void
ClienteNotificaciones
(business)
grupo
documento
docSeleccionado
: Usuario
: void
: Usuario
: void
- busquedaDocs : org.jdesktop.swingx.JXSearchField
- lmdSeparador : org.jdesktop.swingx.JXTitledSeparator
- paneLMD
: javax.swing.JScrollPane
- tablaLMDdocs : org.jdesktop.swingx.JXTable
= new HashSet(0)
GestionDeCambiosFrame
* usuarioConectado : Usuario
* parent
: MainFrame
- bajaDoc
: javax.swing.JButton
- creaDoc
: javax.swing.JButton
- creaU
: javax.swing.JButton
- documentosSol
: org.jdesktop.swingx.JXTitledPanel
- eliU
: javax.swing.JButton
- modU
: javax.swing.JButton
- perDoc
: javax.swing.JButton
- revDoc
: javax.swing.JButton
- solicitudes
: org.jdesktop.swingx.JXTitledPanel
- verDoc
: javax.swing.JButton
+
getTablaLMD ()
: JXTable
+
setTablaLMD (JXTable jXTable1) : void
+ <<Constructor>> DocumentosLMDPanel ()
initComponents ()
: void
+ <<Constructor>> Grupo ()
+ <<Constructor>> Grupo (int grupoId, String grupoNombre)
+ <<Constructor>> Grupo (int grupoId, String grupoNombre,
Set usuarios)
+
getGrupoId ()
: int
+
setGrupoId (int grupoId)
: void
+
getGrupoNombre ()
: String
+
setGrupoNombre (String grupoNombre)
: void
+
getUsuarios ()
: Set
+
setUsuarios (Set usuarios)
: void
: String
: void
+ <<Constructor>> GestionDeCambiosFrame (MainFrame parent,
Usuario usuarioConectado)
cerrarFrame ()
initComponents ()
creaDocActionPerformed (java.awt.event.
ActionEvent evt)
verDocActionPerformed (java.awt.event.
ActionEvent evt)
perDocActionPerformed (java.awt.event.
ActionEvent evt)
bajaDocActionPerformed (java.awt.event.
ActionEvent evt)
revDocActionPerformed (java.awt.event.
ActionEvent evt)
creaUActionPerformed (java.awt.event.
ActionEvent evt)
modUActionPerformed (java.awt.event.
ActionEvent evt)
eliUActionPerformed (java.awt.event.
ActionEvent evt)
: byte[]
: void
: boolean
: void
: boolean
: void
: boolean
: void
: Date
: void
DesktopBorder
(utilities)
- image : BufferedImage
+ <<Constructor>> DesktopBorder (BufferedImage image)
+
paintBorder (Component c, Graphics g, : void
int x, int y, int width, int height)
+
getBorderInsets (Component c)
: Insets
+
isBorderOpaque ()
: boolean
: Date
: void
UsuariosDialog
<<Unresolved Class>>
JInternalFrame
(swing)
borderNuevo
GestionDeCambiosDocumento
: Date
: void
+
+
+
+
*
*
*
*
*
*
-
: boolean
: void
: Boolean
: void
: String
: void
: short
: void
: Date
: void
CAMBIO_PERMISO
BAJA_DOCUMENTO
REVOCAR_PERMISO
NUEVA_VERSION
tipo
documentos
docSeleccionado
usuarioConectado
notificaciones
parent
cancelarBoton
docsAprobadosLabel
docsExplorer
exploradorDocumentos
jXTreeTable1
solicitudBoton
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
int
int
int
int
int
Documentos
Documento
Usuario
Notificaciones
MainFrame
javax.swing.JButton
javax.swing.JLabel
javax.swing.JScrollPane
org.jdesktop.swingx.JXTitledPanel
org.jdesktop.swingx.JXTreeTable
javax.swing.JButton
=1
=2
=3
=4
usuarios
Usuarios
(business)
* sesionAbierta : Session
= new Notificaciones()
panelOpciones
panelDatos
utilidadesUsuarios
usuarios
: boolean
: void
+ <<Constructor>> GestionDeCambiosDocumento (MainFrame par
ent, boolean modal,
Usuario usuarioConectado, int tipo)
: int
: void
-
: boolean
: void
-
initComponents ()
solicitudBotonActionPerformed (java.awt.
event.ActionEvent evt)
cancelarBotonActionPerformed (java.awt.
event.ActionEvent evt)
<<Unresolved Class>>
JPanel
(swing)
panelGeneral
panelUsuarios
panelPerfiles
gruposTab
: void
: void
jPanel1
notificacionPanel
grupoPanel
: void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
getUsuarioById (int usuarioId)
getUsuarioByIdSession (int usuarioId)
crearSesion ()
abrirSesion ()
cerrarSesion ()
getPerfilById (short perfilId)
getGrupoById (int grupoId)
getAllGrupos ()
getAllPerfiles ()
getUsuariosEnSistema ()
getListaUsuarios ()
getListaUsuarios (Documento documento)
getListaUsuariosByGrupo (int grupo)
getListaUsuariosByPerfil (short perfil)
guardarUsuario (Usuario usuarioAcrear)
eliminarUsuario (Usuario usuarioById)
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
Usuario
Usuario
void
void
void
Perfil
Grupo
utilidadUsuarios
List
List
DefaultTableModel
DefaultListModel<String>
DefaultListModel<String>
DefaultListModel<String>
DefaultListModel<String>
void
void
panelDatos
busquedaUsuariosPanel
: String
: void
utilidadUsuarios
usuarios
EscritorioDialog
<<Unresolved Class>>
- jButton1
: javax.swing.JButton
- jButton2
: javax.swing.JButton
- jCheckBox1 : javax.swing.JCheckBox
- jComboBox1 : javax.swing.JComboBox
- jLabel1
: javax.swing.JLabel
- jLabel2
: javax.swing.JLabel
- jScrollPane1 : javax.swing.JScrollPane
- jXTable1
: org.jdesktop.swingx.JXTable
crearU
* escritorioApintar
: JDesktopPane
JButton
editarGrupo
* borderAnterior
: Border
cancelarBoton
aceptar
(swing)
editarUsuario
cancelar
jButton3
* borderNuevo
: DesktopBorder
agregar
cancelar
solicitudBoton
eliminarUsuario
pasarIzq
remover
guardar
- aceptar
: javax.swing.JButton
aplicar
cancelarBoton
cacelar
pasarDer
eliimnar
- aparenciaEscritorio : org.jdesktop.swingx.JXTitledSeparator editarOpciones
guardarBoton
editarPerfiles
- aplicar
: javax.swing.JButton
crearUsuario
- cancelar
: javax.swing.JButton
- escritorioPreview
: org.jdesktop.swingx.JXImageView
procesosRelacionadosBotondocsPermitidos
nombreLabel
jLabel1
estadoDocs
fimaLabel
borrarBoton
copiarR
agregarSubproceso
pasarUsuarioA
editarProceso
agregarCuenta
guardarBoton
pasarUsuarioR
cancelarBoton
editarCuenta
cancelarBoton
aceptarBoton
enviarTexto
cancelarBoton
cancelarBoton
pasarUsuarioC
aceptarBoton
eliminarProceso
actualizarEmails
descripcionDocumento
cerrar
agregarProceso
cancelarBoton
aceptarBoton
- listaEscritorio
: javax.swing.JList
- paneEscritorios
: javax.swing.JScrollPane
jLabel3
<<Unresolved Class>>
- previewLabel
: org.jdesktop.swingx.JXLabel
jLabel5
JLabel
jLabel7
+ <<Constructor>> EscritorioDialog (java.awt.Frame parent,
jLabel1
(swing)
jLabel1
perfilLabel
boolean modal,
descLabel
jLabel2
JDesktopPane escritorioApintar)
jLabel6
usuariosCredTitlePane
docsAprobadosLabel
perfilLabel
jLabel4
initComponents ()
: void
labelOpciones
jLabel2
+
pintarDefault ()
: void
listaEscritorioValueChanged (javax.
: void
swing.event.ListSelectionEvent evt)
aplicarActionPerformed (java.awt.event.
: void
emailLabel
fCreacionLabel
labelTitulo
jLabel9
labelUsuarioC
salidaLabel
jLabel1
jLabel4
versionActualLabel
servidorSalidaLabel
textoSolicitud
jLabel3
procesoLabel
procesandoTexto
labelUsuarioR
servidorEntradaLabel
jLabel2
jLabel5
labelUsuarioA
passLabel
docNombreLabel
fInactivacionLabel
entradaLabel
ActionEvent evt)
cancelarActionPerformed (java.awt.event. : void
ActionEvent evt)
aceptarActionPerformed (java.awt.event. : void
ActionEvent evt)
: void
: Set
: void
: Set
: void
: Set
: void
borderAnterior
utilidadUsuarios
repetirContrasena
esUsuarioNuevo
usuario
parent
esMicuenta
apellido
cancelarBoton
cargo
cuentasEmail
estado
fimaLabel
firma
grupoCheck
grupoCombo
grupoPanel
guardarBoton
jLabel1
jLabel2
jLabel3
jLabel4
jLabel5
jLabel6
jLabel7
jXTitledSeparator1
nombre
nombreUsuario
password
perfilLabel
perfiles
repetirPassword
ssoCheck
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
Usuarios
boolean
boolean
Usuario
Frame
boolean
javax.swing.JTextField
javax.swing.JButton
javax.swing.JTextField
javax.swing.JButton
javax.swing.JComboBox
javax.swing.JLabel
javax.swing.JTextField
javax.swing.JCheckBox
javax.swing.JComboBox
javax.swing.JPanel
javax.swing.JButton
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JLabel
org.jdesktop.swingx.JXTitledSeparator
javax.swing.JTextField
javax.swing.JTextField
javax.swing.JPasswordField
javax.swing.JLabel
javax.swing.JComboBox
javax.swing.JPasswordField
javax.swing.JCheckBox
= new Usuarios()
= false
= false
= false
ReferenciasDialog
- jButton1
: javax.swing.JButton
- jLabel1
: javax.swing.JLabel
- jLabel2
: javax.swing.JLabel
- jScrollPane1 : javax.swing.JScrollPane
- jXTable1
: org.jdesktop.swingx.JXTable
NotificacionDaemon
(utilities)
parent
MainFrame
*
*
*
*
*
*
-
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
: void
-
SolicitudDialog
initComponents ()
: void
agregarDesActionPerformed (java.awt. : void
event.ActionEvent evt)
= new Procesos()
= new Documentos()
+ <<Constructor>> NotaCreacionDocumento (java.awt.
Frame parent, Component c,
DelegarCreacion dcreacion,
boolean modal)
= false
-
+ <<Constructor>> RelacionarProcesos (java.awt.
Frame parent, boolean modal,
Proceso proceso)
+ <<Constructor>> RelacionarProcesos (java.awt.
Frame parent, boolean modal,
Documento documento)
initComponents ()
: void
cacelarActionPerformed (java.awt.event. : void
ActionEvent evt)
agregarActionPerformed (java.awt.event. : void
ActionEvent evt)
removerActionPerformed (java.awt.event. : void
ActionEvent evt)
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
LinkedList<String>
Usuario
IconoBandejaWindows
LinkedList<Integer>
NotificacionDaemon
NotificacionDaemon
javax.swing.JMenuItem
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JMenuItem
javax.swing.JButton
javax.swing.JButton
javax.swing.JDesktopPane
javax.swing.JLabel
javax.swing.JMenu
javax.swing.JMenu
javax.swing.JMenuBar
javax.swing.JMenuItem
javax.swing.JPanel
javax.swing.JToolBar.Separator
javax.swing.JSplitPane
javax.swing.JToolBar
org.jdesktop.swingx.JXStatusBar
org.jdesktop.swingx.JXTitledPanel
= null
= false
= new LinkedList<>()
*
*
*
-
cliente
parent
usuarioConectado
actualizarBoton
cuerpoNotificacionEditorPane
cuerpoNotificacionPane
divisorPanes
jButton1
notificacionLabel
notificacionPanel
notificacionesInternoPane
notificacionesMenu
notificacionesTabs
tablaNotificaciones
:
:
:
:
:
:
:
:
:
:
:
:
:
:
parent
procesos
eliminarBloqueado
agregarProceso
agregarSubproceso
arbolPane
arbolProcesos
cerrar
editarProceso
eliminarProceso
jLabel4
jLabel5
paneProceso
procesoLabel
procesoSeleccionado
procesosRelacionadosBoton
procesosTitlePane
propiedadesPane
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
+
+
+
: LinkedList<String>
: LinkedList<Integer>
: void
+
: void
: void
usuarioConectado
Usuario
(entity)
-
: void
: void
: void
: void
usuarioAutenticado
usuarioConectado
usuarioCuenta
solicitante
usuario
: void
: void
: void
: void
: void
+
+
+
+
+
+
+
+
+
+
+
+
+
+
: void
: void
IconoBandejaWindows
: void
: JButton
: void
iconobandeja
parent
+ <<Constructor>> IconoBandejaWindows (Image imagenDeIcono
)
+
mostrarNotificacionDeDocumentoDeProcedim
: void
iento (MainFrame padreGeneral,
String notificacion)
+
displayMessage (String caption,
: void
String text, MessageType messageType)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
= new Procesos()
= true
CuentasEmailDialog
* usuarioCuenta
: Usuario
* utilidadCuentas : Cuentas
* utilidadUsuarios : Usuarios
* parent
: Frame
- actualizarEmails : javax.swing.JButton
- agregarCuenta
: javax.swing.JButton
- cancelarBoton
: javax.swing.JButton
- editarCuenta
: javax.swing.JButton
- emailSeparador : org.jdesktop.swingx.JXTitledSeparator
- paneCuentas
: javax.swing.JScrollPane
- tablaCuentas
: org.jdesktop.swingx.JXTable
procesoFrame
: void
: void
: void
: Procesos
: void
+ <<Constructor>> CuentasEmailDialog (java.awt.
Frame parent, boolean modal)
+ <<Constructor>> CuentasEmailDialog (java.awt.
Frame parent, boolean modal,
Usuario usuario)
initComponents ()
formComponentShown (java.awt.event.
ComponentEvent evt)
agregarCuentaActionPerformed (java.awt.
event.ActionEvent evt)
editarCuentaActionPerformed (java.awt.
event.ActionEvent evt)
cancelarBotonActionPerformed (java.awt.
event.ActionEvent evt)
tablaCuentasMouseClicked (java.awt.
event.MouseEvent evt)
actualizarEmailsActionPerformed (java.
awt.event.ActionEvent evt)
+
main (String args[])
refrescarTablaCuentas ()
: JXTreeTable
: void
: void
: void
: void
: void
: void
: void
*
*
-
: void
: void
: void
documento
parent
aceptarBoton
aprobacion
creacion
fAprobacionLabel
fCreacionLabel
fRevisionLabel
id
idInternaLabel
jXLabel8
nombre
nombreLabel
panelDatos
revision
verDescripcion
verHistorialVersiones
verHistorialVersiones1
versionActual
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
Documento
MainFrame
javax.swing.JButton
org.jdesktop.swingx.JXTextField
org.jdesktop.swingx.JXTextField
org.jdesktop.swingx.JXLabel
org.jdesktop.swingx.JXLabel
org.jdesktop.swingx.JXLabel
org.jdesktop.swingx.JXTextField
org.jdesktop.swingx.JXLabel
org.jdesktop.swingx.JXLabel
org.jdesktop.swingx.JXTextField
org.jdesktop.swingx.JXLabel
org.jdesktop.swingx.JXPanel
org.jdesktop.swingx.JXTextField
org.jdesktop.swingx.JXButton
org.jdesktop.swingx.JXButton
org.jdesktop.swingx.JXButton
org.jdesktop.swingx.JXTextField
+ <<Constructor>> DocumentosPropiedades (java.awt.
Frame parent, boolean modal,
Documento documento)
initComponents ()
: void
verDescripcionActionPerformed (java.awt. : void
event.ActionEvent evt)
aceptarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
: void
: void
: void
: void
: void
: void
DescripcionDocumentos
* descripcion
: String
- aceptarBoton
: org.jdesktop.swingx.JXButton
- editorPaneDescripcion : org.jdesktop.swingx.JXEditorPane
- paneDescripcion
: javax.swing.JScrollPane
+ <<Constructor>> DescripcionDocumentos (java.awt.
Frame parent, Component comp,
boolean modal, Documento documento)
initComponents ()
: void
aceptarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
dcreacion
DelegarCreación
NotasGenerales
= ""
+ <<Constructor>> NotasGenerales (java.awt.Frame parent,
Component c, boolean modal)
+
getNotaEntregable ()
: String
+
setNotaEntregable (String notaEntregable : void
)
initComponents ()
: void
agregarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
*
*
*
*
*
*
*
*
-
usuarios
version
descripcion
notaCreador
usuarioConectado
documento
esNuevaVersion
pnmodelo
aceptarBoton
borrarBoton
busquedaUsuariosPanel
cancelarBoton
copiarR
descripcionDocumento
docNombreLabel
fechasEntrega
labelTitulo
labelUsuarioA
labelUsuarioC
labelUsuarioR
listaUsuario
nombreDocumento
paneUsuarios
panelDatos
pasarUsuarioA
pasarUsuarioC
pasarUsuarioR
usuarioAprobador
usuarioCreacion
usuarioRevision
versionActual
versionActualLabel
versionable
versionesMax
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
Usuarios
boolean
String
String
Usuario
Documento
boolean
SpinnerNumberModel
javax.swing.JButton
javax.swing.JButton
javax.swing.JPanel
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JLabel
org.jdesktop.swingx.JXDatePicker
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JList
javax.swing.JTextField
javax.swing.JScrollPane
javax.swing.JPanel
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JTextField
javax.swing.JTextField
javax.swing.JTextField
javax.swing.JTextField
javax.swing.JLabel
javax.swing.JCheckBox
javax.swing.JSpinner
+
getNotaCreador ()
+
setNotaCreador (String notaCreador)
+
getDescripcion ()
+
setDescripcion (String descripcion)
+ <<Constructor>> DelegarCreación (java.awt.Frame parent,
boolean modal,
Usuario usuarioConectado)
NuevoProcesoFrame
*
*
*
*
*
-
= true
= ""
= ""
= false
= new SpinnerNumberModel(1,1,3,1)
procesoNuevo
procesoFrame
nodoNuevo
esModificado
esSubnivel
IDproc
aceptarBoton
cancelarBoton
descripcion
jLabel1
jLabel2
jLabel3
jScrollPane2
nombre
:
:
:
:
:
:
:
:
:
:
:
:
:
:
Proceso
ProcedimientosFrame
ProcesoTreeTableNode
boolean
boolean
javax.swing.JTextField
javax.swing.JButton
javax.swing.JButton
org.jdesktop.swingx.JXEditorPane
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JScrollPane
javax.swing.JTextField
= false
= false
+ <<Constructor>> NuevoProcesoFrame (java.awt.
Frame parent, boolean modal)
* <<Constructor>> NuevoProcesoFrame (MainFrame parent,
boolean b, ProcedimientosFrame aThis)
* <<Constructor>> NuevoProcesoFrame (MainFrame parent,
boolean b, ProcedimientosFrame aThis,
Proceso nodo)
*
-
<<Constructor>> NuevoProcesoFrame (MainFrame parent,
ProcedimientosFrame aThis,
String idPadre)
initComponents ()
: void
aceptarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
cancelarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
: String
: void
: String
: void
utilidadCuentas
Cuentas
(business)
+ <<Constructor>> DelegarCreación (java.awt.Frame parent,
boolean modal,
Usuario usuarioConectado,
Documento documento)
+
+
-
cerrarFrame ()
setDatos ()
initComponents ()
copiarRActionPerformed (java.awt.event.
ActionEvent evt)
pasarUsuarioCActionPerformed (java.awt.
event.ActionEvent evt)
pasarUsuarioRActionPerformed (java.awt.
event.ActionEvent evt)
pasarUsuarioAActionPerformed (java.awt.
event.ActionEvent evt)
borrarBotonActionPerformed (java.awt.
event.ActionEvent evt)
versionableStateChanged (javax.swing.
event.ChangeEvent evt)
descripcionDocumentoActionPerformed (jav
a.awt.event.ActionEvent evt)
aceptarBotonActionPerformed (java.awt.
event.ActionEvent evt)
cancelarBotonActionPerformed (java.awt.
event.ActionEvent evt)
nombreDocumentoFocusGained (java.awt.
event.FocusEvent evt)
* sesionAbierta : Session
: void
: void
: void
: void
utilidadCuentas
: void
+ getCuentaById (String cuentaId)
: Cuenta
+ getCuentaDefaultByUsuario (int usuarioId : Cuenta
)
+ getCuentasDeUsuario (int usuarioId)
: DefaultTableModel
+ guardarCuenta (Cuenta cuentaAcrear)
: void
+ crearSesion ()
: void
+ abrirSesion ()
: void
+ cerrarSesion ()
: void
: void
: void
CuentaEmail
: void
: void
: void
: void
: void
: void
*
*
*
*
-
usuarioCuenta
cuenta
utilidadCuentas
esModificado
cancelarBoton
cuentaDefault
cuentaEstado
direccionEmail
emailLabel
entradaLabel
fCreacionLabel
fInactivacionLabel
fechaCreacion
fechaInactivacion
guardarBoton
imapCheck
jLabel9
passLabel
password
puertoEntrada
puertoSalida
salidaLabel
separadorTitulo
servidorEntrada
servidorEntradaLabel
servidorSalida
servidorSalidaLabel
sslCheck
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
Usuario
Cuenta
Cuentas
boolean
javax.swing.JButton
javax.swing.JCheckBox
javax.swing.JComboBox
javax.swing.JTextField
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JFormattedTextField
javax.swing.JFormattedTextField
javax.swing.JButton
javax.swing.JCheckBox
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JPasswordField
javax.swing.JFormattedTextField
javax.swing.JFormattedTextField
javax.swing.JLabel
org.jdesktop.swingx.JXTitledSeparator
javax.swing.JTextField
javax.swing.JLabel
javax.swing.JTextField
javax.swing.JLabel
javax.swing.JCheckBox
= new Cuentas()
= false
+ <<Constructor>> CuentaEmail (java.awt.Frame parent,
boolean modal)
+ <<Constructor>> CuentaEmail (Frame parent, boolean b,
Usuario usuario)
+ <<Constructor>> CuentaEmail (Frame parent, boolean b,
Cuenta cuenta)
+
llenarDatos ()
: void
+
guardarCuenta ()
: void
initComponents ()
: void
guardarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
cancelarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
+
main (String args[])
: void
nodoNuevo
procesoNuevo
proceso
Cuenta
(entity)
-
cuentaId
usuario
cuentaEmail
cuentaSmtp
cuentaEntrada
cuentaImap
cuentaSsl
cuentaPassword
cuentaDefault
cuentaPuertoSmtp
cuentaPuertoEntrada
cuentaActiva
cuentaFechaCreacion
cuentaFechaInactivacion
:
:
:
:
:
:
:
:
:
:
:
:
:
:
String
Usuario
String
String
String
boolean
boolean
String
boolean
String
String
boolean
Date
Date
+ <<Constructor>> Cuenta ()
+ <<Constructor>> Cuenta (String cuentaId,
Usuario usuario, String cuentaEmail,
String cuentaSmtp,
String cuentaEntrada,
boolean cuentaImap, boolean cuentaSsl,
String cuentaPassword,
boolean cuentaDefault,
String cuentaPuertoSmtp,
String cuentaPuertoEntrada,
boolean cuentaActiva,
Date cuentaFechaCreacion)
+ <<Constructor>> Cuenta (String cuentaId,
Usuario usuario, String cuentaEmail,
String cuentaSmtp,
String cuentaEntrada,
boolean cuentaImap, boolean cuentaSsl,
String cuentaPassword,
boolean cuentaDefault,
String cuentaPuertoSmtp,
String cuentaPuertoEntrada,
boolean cuentaActiva,
Date cuentaFechaCreacion,
Date cuentaFechaInactivacion)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
getCuentaId ()
setCuentaId (String cuentaId)
getUsuario ()
setUsuario (Usuario usuario)
getCuentaEmail ()
setCuentaEmail (String cuentaEmail)
getCuentaSmtp ()
setCuentaSmtp (String cuentaSmtp)
getCuentaEntrada ()
setCuentaEntrada (String cuentaEntrada)
isCuentaImap ()
setCuentaImap (boolean cuentaImap)
isCuentaSsl ()
setCuentaSsl (boolean cuentaSsl)
getCuentaPassword ()
setCuentaPassword (String cuentaPassword
)
isCuentaDefault ()
setCuentaDefault (boolean cuentaDefault)
getCuentaPuertoSmtp ()
setCuentaPuertoSmtp (String cuentaPuerto
Smtp)
getCuentaPuertoEntrada ()
setCuentaPuertoEntrada (String cuentaPue
rtoEntrada)
isCuentaActiva ()
setCuentaActiva (boolean cuentaActiva)
getCuentaFechaCreacion ()
setCuentaFechaCreacion (Date cuentaFecha
Creacion)
getCuentaFechaInactivacion ()
setCuentaFechaInactivacion (Date cuentaF
echaInactivacion)
cuenta
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
int
Perfil
Grupo
String
String
String
String
String
Date
Date
boolean
boolean
byte[]
String
Set
Set
Set
Set
Set
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
= new HashSet(0)
getUsuarioId ()
setUsuarioId (int usuarioId)
getPerfil ()
setPerfil (Perfil perfil)
getGrupo ()
setGrupo (Grupo grupo)
getUsuarioNick ()
setUsuarioNick (String usuarioNick)
getUsuarioPassword ()
setUsuarioPassword (String usuarioPasswo
rd)
getUsuarioNombre ()
setUsuarioNombre (String usuarioNombre)
getUsuarioApellido ()
setUsuarioApellido (String usuarioApelli
do)
getUsuarioCargo ()
setUsuarioCargo (String usuarioCargo)
getUsuarioFechaCreacion ()
setUsuarioFechaCreacion (Date usuarioFec
haCreacion)
getUsuarioFechaInactivacion ()
setUsuarioFechaInactivacion (Date usuari
oFechaInactivacion)
isUsuarioActivo ()
setUsuarioActivo (boolean usuarioActivo)
isUsuarioSuperUsuario ()
setUsuarioSuperUsuario (boolean usuarioS
uperUsuario)
getUsuarioPkey ()
setUsuarioPkey (byte usuarioPkey[])
getUsuarioFirma ()
setUsuarioFirma (String usuarioFirma)
getDocumentosForUsuarioAprobadorId ()
setDocumentosForUsuarioAprobadorId (Set
documentosForUsuarioAprobadorId)
getDocumentosForUsuarioRevisorId ()
setDocumentosForUsuarioRevisorId (Set do
cumentosForUsuarioRevisorId)
getCuentas ()
setCuentas (Set cuentas)
getPermisoUsuarioDocumentos ()
setPermisoUsuarioDocumentos (Set permiso
UsuarioDocumentos)
getDocumentosForUsuarioCreadorId ()
setDocumentosForUsuarioCreadorId (Set do
cumentosForUsuarioCreadorId)
<<Unresolved Class>>
TrayIcon
(awt)
DocumentosPropiedades
= new Cuentas()
= new Usuarios()
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
+ <<Constructor>> Usuario (int usuarioId, Perfil perfil,
Grupo grupo, String usuarioNick,
String usuarioPassword,
String usuarioNombre,
String usuarioApellido,
String usuarioCargo,
Date usuarioFechaCreacion,
Date usuarioFechaInactivacion,
boolean usuarioActivo,
boolean usuarioSuperUsuario,
byte usuarioPkey[],
String usuarioFirma,
Set documentosForUsuarioAprobadorId,
Set documentosForUsuarioRevisorId,
Set cuentas,
Set permisoUsuarioDocumentos,
Set documentosForUsuarioCreadorId)
parent
: void
+
+
+
+
+ <<Constructor>> ProcedimientosFrame (final MainFrame par
ent)
validarOpciones ()
initComponents ()
+
cargarProcesos ()
+
getProcesos ()
cerrarActionPerformed (java.awt.event.
ActionEvent evt)
+
getTreeTable ()
agregarProcesoActionPerformed (java.awt.
event.ActionEvent evt)
arbolProcesosValueChanged (javax.swing.
event.TreeSelectionEvent evt)
editarProcesoActionPerformed (java.awt.
event.ActionEvent evt)
agregarSubprocesoActionPerformed (java.
awt.event.ActionEvent evt)
eliminarProcesoActionPerformed (java.
awt.event.ActionEvent evt)
procesosRelacionadosBotonActionPerformed
(java.awt.event.ActionEvent evt)
cerrarFrame ()
* notaEntregable
: String
- agregarBoton
: org.jdesktop.swingx.JXButton
- editorSolicitud
: org.jdesktop.swingx.JXEditorPane
- solicitudEditorPane : javax.swing.JScrollPane
usuarioId
perfil
grupo
usuarioNick
usuarioPassword
usuarioNombre
usuarioApellido
usuarioCargo
usuarioFechaCreacion
usuarioFechaInactivacion
usuarioActivo
usuarioSuperUsuario
usuarioPkey
usuarioFirma
documentosForUsuarioAprobadorId
documentosForUsuarioRevisorId
cuentas
permisoUsuarioDocumentos
documentosForUsuarioCreadorId
+ <<Constructor>> Usuario ()
+ <<Constructor>> Usuario (int usuarioId, Perfil perfil,
Grupo grupo, String usuarioNick,
String usuarioPassword,
String usuarioNombre,
String usuarioApellido,
String usuarioCargo,
Date usuarioFechaCreacion,
boolean usuarioActivo,
boolean usuarioSuperUsuario)
: void
initComponents ()
: void
agregarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
MainFrame
Procesos
boolean
javax.swing.JButton
javax.swing.JButton
org.jdesktop.swingx.JXTitledPanel
org.jdesktop.swingx.JXTreeTable
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JLabel
javax.swing.JLabel
javax.swing.JScrollPane
javax.swing.JLabel
javax.swing.JTextField
javax.swing.JButton
org.jdesktop.swingx.JXTitledSeparator
org.jdesktop.swingx.JXTitledPanel
procesos
procesosAux
=0
=0
+ <<Constructor>> NotificacionesFrame (String title)
+ <<Constructor>> NotificacionesFrame (MainFrame parent,
Usuario usuarioConectado)
cerrarFrame ()
: void
+
cargarNotificaciones ()
: void
initComponents ()
: void
jButton1ActionPerformed (java.awt.event. : void
ActionEvent evt)
actualizarBotonActionPerformed (java.
: void
awt.event.ActionEvent evt)
tablaNotificacionesMouseClicked (java.
: void
awt.event.MouseEvent evt)
ProcedimientosFrame
*
*
*
-
= null
run ()
ClienteNotificaciones
MainFrame
Usuario
javax.swing.JButton
org.jdesktop.swingx.JXEditorPane
javax.swing.JScrollPane
javax.swing.JSplitPane
javax.swing.JButton
org.jdesktop.swingx.JXTitledSeparator
javax.swing.JPanel
javax.swing.JScrollPane
javax.swing.JPopupMenu
javax.swing.JTabbedPane
org.jdesktop.swingx.JXTable
+ <<Constructor>> SolicitudDialog (MainFrame parent,
Usuario usuarioConectado,
boolean esDocumento, int tipo)
initComponents ()
: void
enviarTextoActionPerformed (java.awt.
: void
event.ActionEvent evt)
cancelarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
NotaCreacionDocumento
* dcreacion
: DelegarCreacion
- agregarBoton : org.jdesktop.swingx.JXButton
- notaDocs
: org.jdesktop.swingx.JXEditorPane
- paneEditor
: javax.swing.JScrollPane
RelacionarProcesos
listaFrames
usuarioAutenticado
iconobandeja
opcionesActivas
notificador1
notificacionesEntrantes
bloquearEstacion
botonCambios
botonConfiguracion
botonDocumentos
botonNotificaciones
botonProcesos
escritorioMenu
jButton1
jButton6
jDesktopPane1
jLabel1
jMenu1
jMenu3
jMenuBar1
jMenuItem4
jPanel1
jSeparator1
jSplitPane1
jToolBar1
jXStatusBar1
jXTitledPanel1
getListaFrames ()
getOpcionesActivas ()
setOpcionesActivas (LinkedList<Integer>
opcionesActivas)
setListaFrames (LinkedList<String>
listaFrames)
+ <<Constructor>> MainFrame ()
+ <<Constructor>> MainFrame (Usuario usuarioAutenticado)
iniciarNotificador (NotificacionDaemon d
emonio)
pararNotificador (NotificacionDaemon dem
onio)
validarOpciones ()
+
insertarEnDesktop (final JInternalFrame
frame)
initComponents ()
escritorioMenuActionPerformed (java.awt.
event.ActionEvent evt)
jButton6ActionPerformed (java.awt.event.
ActionEvent evt)
botonProcesosActionPerformed (java.awt.
event.ActionEvent evt)
botonDocumentosActionPerformed (java.
awt.event.ActionEvent evt)
botonCambiosActionPerformed (java.awt.
event.ActionEvent evt)
botonNotificacionesActionPerformed (java
.awt.event.ActionEvent evt)
jButton1ActionPerformed (java.awt.event.
ActionEvent evt)
bloquearEstacionActionPerformed (java.
awt.event.ActionEvent evt)
jMenuItem4ActionPerformed (java.awt.
event.ActionEvent evt)
+
getBotonProcesos ()
+
setBotonProcesos (JButton botonProcesos)
: void
: void
: void
: String
parent
* usuarioConectado
: Usuario
* parent
: MainFrame
* documento
: String
* esDocumento
: boolean
* tipo
: int
- cancelarBoton
: javax.swing.JButton
- enviarTexto
: javax.swing.JButton
- jScrollPane1
: javax.swing.JScrollPane
- solicitudEditorPane : javax.swing.JEditorPane
- textoSolicitud
: javax.swing.JLabel
* usuario
: Usuario
* cliente
: ClienteNotificaciones
* folder
: IMAPFolder
* bandeja
: IconoBandejaWindows
* padreGeneral : MainFrame
* tiempoEspera : int
* messageCount : int
* estado
: int
verificacionNotificacion
LMRDocumento
+ <<Constructor>> LMRDocumento (java.awt.Frame parent,
boolean modal)
initComponents ()
: void
+
main (String args[])
: void
: void
+
+ <<Constructor>> ReferenciasDialog (java.awt.
Frame parent, boolean modal)
initComponents ()
: void
+
main (String args[])
: void
- aceptarBoton
: javax.swing.JButton
- paneDocs
: javax.swing.JScrollPane
- versionesAnteriores : org.jdesktop.swingx.JXTable
: void
: void
+ <<Constructor>> NotificacionDaemon (MainFrame padreGener
al, Usuario usuarioConectado,
int tiempoEspera,
IconoBandejaWindows bandeja,
int estado)
+ <<Constructor>> ProcesandoDialog (java.awt.Frame parent,
boolean modal)
+
getjLabel2 ()
: JLabel
+
setjLabel2 (JLabel jLabel2)
: void
initComponents ()
: void
+ <<Constructor>> NotaDescripcionDocumento (java.awt.
Frame parent, Component comp,
boolean modal,
DelegarCreacion dcreacion)
cliente
: void
: void
notificacionesEntrantes
notificador1
NotaDescripcionDocumento
* descripcion : String
* dcreacion
: DelegarCreacion
- agregarDes : org.jdesktop.swingx.JXButton
- editorDes
: org.jdesktop.swingx.JXEditorPane
- paneDes
: javax.swing.JScrollPane
+
: void
: void
NotificacionesFrame
+
llenarDatosDeUsuario ()
+ <<Constructor>> UsuariosDialog (java.awt.Frame parent,
boolean modal)
initComponents ()
apellidoActionPerformed (java.awt.event.
ActionEvent evt)
cargoActionPerformed (java.awt.event.
ActionEvent evt)
grupoCheckItemStateChanged (java.awt.
event.ItemEvent evt)
guardarBotonActionPerformed (java.awt.
event.ActionEvent evt)
passwordKeyPressed (java.awt.event.
KeyEvent evt)
cancelarBotonActionPerformed (java.awt.
event.ActionEvent evt)
repetirPasswordKeyTyped (java.awt.event.
KeyEvent evt)
passwordFocusGained (java.awt.event.
FocusEvent evt)
passwordMouseClicked (java.awt.event.
MouseEvent evt)
cuentasEmailActionPerformed (java.awt.
event.ActionEvent evt)
firmaActionPerformed (java.awt.event.
ActionEvent evt)
+
main (String args[])
cargarGrupos ()
guardarDatos ()
controlguardado ()
+ <<Constructor>> FiltroDeProyectoCliente (java.awt.
Frame parent, boolean modal)
initComponents ()
: void
+
main (String args[])
: void
+
: void
: void
: void
<<Unresolved Class>>
JFrame
(swing)
+ <<Constructor>> UsuariosDialog (java.awt.Frame parent,
boolean modal,
Usuario usuarioAmodificar,
boolean esMiCuenta)
FiltroDeProyectoCliente
bajaDoc
botonConfiguracion
creaU
botonNotificaciones
modU
jButton1
cuentasEmail
jButton1
revDoc
actualizarBoton
aceptarBoton
jButton6
guardarBoton
jButton1
verDoc
jButton2
jButton1
botonProcesos
cancelarBoton
perDoc
botonDocumentos
eliU
botonCambios
creaDoc
*
*
*
*
*
*
-
+ <<Constructor>> UsuariosDialog (java.awt.Frame parent,
boolean modal,
Usuario usuarioAmodificar)
gestionCambioDocumento
botonPorAprobar
actualizarTablaUsuarios
botonDelegarbotonLMD
actualizarTabla
guardarBoton
botonPorSubir
revocarPermiso
botonPorRevisar
actualizarPerfiles
usuarioGrupo
aceptarBoton
crearPerfil
asignarPermiso
pasarDer
cancelar
guardar
cancelarBoton
actualizarDocs
pasarIzq
jButton3
cancelar
: Set
+ <<Constructor>> ClienteNotificaciones (MainFrame padreGe
neral, Usuario clienteMail)
+
getSessionGeneral ()
+
getStoreGeneral ()
+
mensajeRecibido (Message message)
+
getMensaje (int i)
+
cargarTablaDeNotificacionesRecibidas (St
ore s
+
DocumentosLMDPanel
Grupo
(entity)
: DocumentoId
: void
: Usuario
: void
* cliente
: Usuario
* sesionGeneral
: javax.mail.Session
* storeGeneral
: Store
* ultimoMensajeRecibido : Message
* padreGeneral
: MainFrame
* mensajes
: Message[]
documentosLMDPanel1
grupoSeleccionado
grupo
- grupoId
: int
- grupoNombre : String
- usuarios
: Set
ProcesandoDialog
Proceso
Procesos
Documentos
Documento
boolean
javax.swing.JButton
javax.swing.JButton
javax.swing.JScrollPane
org.jdesktop.swingx.JXTitledSeparator
javax.swing.JButton
org.jdesktop.swingx.JXTreeTable
: void
=1
=2
=3
initComponents ()
: void
aceptarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
<<Unresolved Class>>
JDialog
(swing)
:
:
:
:
:
:
:
:
:
:
:
: void
: JButton
: void
: void
: void
: void
: void
documentosPorSubirPanel1
- barraProgreso
: javax.swing.JProgressBar
- procesandoTexto : javax.swing.JLabel
proceso
procesosAux
documentos
documento
isProceso
agregar
cacelar
paneRelacion
procesosRel
remover
tablaUsuarios
Usuario
MainFrame
Documentos
javax.swing.JButton
javax.swing.JMenuItem
org.jdesktop.swingx.JXStatusBar
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JButton
javax.swing.JMenuItem
org.jdesktop.swingx.JXTitledPanel
org.jdesktop.swingx.JXTreeTable
javax.swing.JScrollPane
javax.swing.JLabel
com.integraitec.docbpm.visual.DocumentosLMDPanel
com.integraitec.docbpm.visual.DocumentosPorAprobarPanel
com.integraitec.docbpm.visual.DocumentosPorRevisarPanel
com.integraitec.docbpm.visual.DocumentosPorSubirPanel
javax.swing.JLabel
javax.swing.JButton
javax.swing.JTabbedPane
javax.swing.JPopupMenu
javax.swing.JMenuItem
javax.swing.JSplitPane
javax.swing.JScrollPane
javax.swing.JPanel
javax.swing.JSplitPane
javax.swing.JPanel
javax.swing.JMenuItem
javax.swing.JMenuItem
javax.swing.JMenuItem
javax.swing.JToolBar
+ <<Constructor>> DocumentosPorSubirPanel ()
+
getTablaSubir ()
: JXTable
+
setTablaSubir (JXTable jXTable1) : void
initComponents ()
: void
= new Grupos()
+ <<Constructor>> UsuariosGruposDialog (java.awt.
Frame parent, boolean modal,
boolean esCreacion, String docNombre,
String nota, Usuario solicitante,
int tipo)
+ <<Constructor>> UsuariosDelGrupoDialog (java.awt.
Frame parent, boolean modal,
Grupo grupo, short tipo)
documento
*
*
*
*
*
-
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
DocumentosPorSubirPanel
- busquedaSubir : org.jdesktop.swingx.JXSearchField
- paneSubir
: javax.swing.JScrollPane
- subirSeparador : org.jdesktop.swingx.JXTitledSeparator
- tablaSubir
: org.jdesktop.swingx.JXTable
UsuariosGruposDialog
getId ()
setId (DocumentoId id)
getUsuarioByUsuarioRevisorId ()
setUsuarioByUsuarioRevisorId (Usuario us
uarioByUsuarioRevisorId)
getUsuarioByUsuarioCreadorId ()
setUsuarioByUsuarioCreadorId (Usuario us
uarioByUsuarioCreadorId)
getUsuarioByUsuarioAprobadorId ()
setUsuarioByUsuarioAprobadorId (Usuario
usuarioByUsuarioAprobadorId)
getDocumentoNombre ()
setDocumentoNombre (String documentoNomb
re)
getDocumentoArchivo ()
setDocumentoArchivo (byte documentoArchi
vo[])
isDocumentoCreado ()
setDocumentoCreado (boolean documentoCre
ado)
isDocumentoRevisado ()
setDocumentoRevisado (boolean documentoR
evisado)
isDocumentoAprobado ()
setDocumentoAprobado (boolean documentoA
probado)
getDocumentoFechaCreado ()
setDocumentoFechaCreado (Date documentoF
echaCreado)
getDocumentoFechaRevisado ()
setDocumentoFechaRevisado (Date document
oFechaRevisado)
getDocumentoFechaAprobado ()
setDocumentoFechaAprobado (Date document
oFechaAprobado)
isDocumentoGrupoRevision ()
setDocumentoGrupoRevision (boolean docum
entoGrupoRevision)
getDocumentoGrupoAprobacion ()
setDocumentoGrupoAprobacion (Boolean doc
umentoGrupoAprobacion)
getDocumentoTipo ()
setDocumentoTipo (String documentoTipo)
getDocumentoPrioridad ()
setDocumentoPrioridad (short documentoPr
ioridad)
getDocumentoFechaEntrega ()
setDocumentoFechaEntrega (Date documento
FechaEntrega)
isDocumentoVersionable ()
setDocumentoVersionable (boolean documen
toVersionable)
getDocumentoVersionmaxima ()
setDocumentoVersionmaxima (int documento
Versionmaxima)
isDocumentoExterno ()
setDocumentoExterno (boolean documentoEx
terno)
getDocumentoDescripcion ()
setDocumentoDescripcion (String document
oDescripcion)
getDocumentosForFkDocumentoRelacionado (
)
setDocumentosForFkDocumentoRelacionado (
Set documentosForFkDocumentoRelacionado)
getPermisoUsuarioDocumentos ()
setPermisoUsuarioDocumentos (Set permiso
UsuarioDocumentos)
getProcesos ()
setProcesos (Set procesos)
getDocumentosForFkDocumentoRelacionado2
()
setDocumentosForFkDocumentoRelacionado2
(Set documentosForFkDocumentoRelacionado
2)
<<Unresolved Interface>>
Border
(border)
DocumentosPorAprobarPanel
+ <<Constructor>> DocumentosPorRevisarPanel ()
+
getTablaRevisados ()
: JXTable
+
setTablaRevisados (JXTable jXTable1) : void
initComponents ()
: void
usuarioConectado
parent
documentos
actualizarDocs
agregarPermisoDocumento
barraEstado
botonDelegar
botonLMD
botonPorAprobar
botonPorRevisar
botonPorSubir
detallesDocumento
docExplorador
docsAprobadosTabla
docsPane
docsPermitidos
documentosLMDPanel1
documentosPorAprobarPanel1
documentosPorRevisarPanel1
documentosPorSubirPanel1
estadoDocs
gestionCambioDocumento
lmd
menuDocs
nuevaVersionDocumento
paneDivisor
paneExpDocs
panelDatos
panelDivisor2
panelOpciones
relacionarProcesos
revocarPermisoDocumento
solicitarDocumento
toolBarAcciones
+ <<Constructor>> DocumentosInternalFrame (MainFrame paren
t, Usuario usuarioConectado)
validarOpciones ()
+
getActualizarDocs ()
+
cargarDocumentosLMD ()
+
cargarDocumentos ()
cerrarFrame ()
initComponents ()
botonDelegarActionPerformed (java.awt.
event.ActionEvent evt)
actualizarDocsActionPerformed (java.awt.
event.ActionEvent evt)
gestionCambioDocumentoActionPerformed (j
ava.awt.event.ActionEvent evt)
docsAprobadosTablaValueChanged (javax.
swing.event.TreeSelectionEvent evt)
docsAprobadosTablaFocusLost (java.awt.
event.FocusEvent evt)
nuevaVersionDocumentoActionPerformed (ja
va.awt.event.ActionEvent evt)
botonPorSubirActionPerformed (java.awt.
event.ActionEvent evt)
botonPorAprobarActionPerformed (java.
awt.event.ActionEvent evt)
botonPorRevisarActionPerformed (java.
awt.event.ActionEvent evt)
solicitarDocumentoActionPerformed (java.
awt.event.ActionEvent evt)
revocarPermisoDocumentoActionPerformed (
java.awt.event.ActionEvent evt)
agregarPermisoDocumentoActionPerformed (
java.awt.event.ActionEvent evt)
detallesDocumentoActionPerformed (java.
awt.event.ActionEvent evt)
relacionarProcesosActionPerformed (java.
awt.event.ActionEvent evt)
lmdStateChanged (javax.swing.event.
ChangeEvent evt)
botonLMDActionPerformed (java.awt.event.
ActionEvent evt)
DocumentosPorRevisarPanel
- busquedaRevisados : org.jdesktop.swingx.JXSearchField
- paneRevisados
: javax.swing.JScrollPane
- revisadosSeparador : org.jdesktop.swingx.JXTitledSeparator
- tablaRevisados
: org.jdesktop.swingx.JXTable
+ <<Constructor>> Documento (DocumentoId id,
Usuario usuarioByUsuarioRevisorId,
Usuario usuarioByUsuarioCreadorId,
Usuario usuarioByUsuarioAprobadorId,
String documentoNombre,
byte documentoArchivo[],
boolean documentoCreado,
boolean documentoRevisado,
boolean documentoAprobado,
Date documentoFechaCreado,
Date documentoFechaRevisado,
Date documentoFechaAprobado,
boolean documentoGrupoRevision,
Boolean documentoGrupoAprobacion,
String documentoTipo,
short documentoPrioridad,
Date documentoFechaEntrega,
boolean documentoVersionable,
int documentoVersionmaxima,
boolean documentoExterno,
String documentoDescripcion,
Set documentosForFkDocumentoRelacionado
, Set permisoUsuarioDocumentos,
Set procesos,
Set documentosForFkDocumentoRelacionado
2)
UsuariosFrame
*
*
*
*
*
-
: void
notificaciones
+ <<Constructor>> Documento ()
+ <<Constructor>> Documento (DocumentoId id,
String documentoNombre,
boolean documentoCreado,
boolean documentoRevisado,
boolean documentoAprobado,
boolean documentoGrupoRevision,
String documentoTipo,
short documentoPrioridad,
Date documentoFechaEntrega,
boolean documentoVersionable,
int documentoVersionmaxima,
boolean documentoExterno)
: void
: void
=1
=2
initComponents ()
: void
pasarIzqActionPerformed (java.awt.event. : void
ActionEvent evt)
pasarDerActionPerformed (java.awt.event. : void
ActionEvent evt)
cancelarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
guardarBotonActionPerformed (java.awt. : void
event.ActionEvent evt)
+
+
Documento
(entity)
: DefaultTableModel
+ <<Constructor>> OpcionesDePerfil (java.awt.Frame parent,
boolean modal, Perfil perfil,
short tipo)
-
+
: Documento
: int
: int
: int
: DefaultTableModel
documentos
-
+
documento
AccionDocumentoRevisar
AccionDocumentoAprobar
AccionDocumentoSubir
-
+
= new Documentos()
= false
=1
=2
: void
: void
: void
: void
OpcionesDePerfil
* perfiles
: Perfiles
* perfil
: Perfil
+ CONSULTA
: short
+ ADMINISTRACION : short
- cancelarBoton
: javax.swing.JButton
- guardarBoton
: javax.swing.JButton
- jButton3
: javax.swing.JButton
- listaOpciones1
: javax.swing.JList
- listaOpciones2
: javax.swing.JList
- opcionesDispPane : javax.swing.JScrollPane
- opcionesSelPane : javax.swing.JScrollPane
- pasarDer
: javax.swing.JButton
- pasarIzq
: javax.swing.JButton
= new Usuarios()
= new Grupos()
+ <<Constructor>> PermisosUsuariosDocumento (java.awt.
Frame parent, boolean modal,
Documento documento)
+ <<Constructor>> PermisosUsuariosDocumento (java.awt.
Frame parent, boolean modal,
Documento documento, int tipoPermiso)
initComponents ()
: void
seleccionGruposItemStateChanged (java. : void
awt.event.ItemEvent evt)
asignarPermisoActionPerformed (java.awt. : void
event.ActionEvent evt)
revocarPermisoActionPerformed (java.awt. : void
event.ActionEvent evt)
cancelarActionPerformed (java.awt.event. : void
ActionEvent evt)
Documentos
(business)
* usuarioConectado : Usuario
* documentosLista : List<Documento>
* modelo
: DocumentosTreeTableModel
- nodos
: LinkedList<DocumentoTreeTableNode>
* sesionAbierta
: Session
* sesionAux
: Session
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
:
: void
notificarSolicitudCambioPerfilDocumento
()
notificarSolicitudCambioPermisoUsuario (
)
notificarCreacion (Usuario solicitante,
Usuario notificado, String documento,
String nota, String fecha)
notificarRevision (Usuario solicitante,
Usuario notificado, String documento,
String nota, String fecha)
notificarAprobacion (Usuario solicitante
, Usuario notificado, String documento,
String nota, String fecha)
notificarDocumentoListo ()
enviarEmail (Usuario emisor,
List usuariosAnotificar,
String subject, String mensaje)
utilidadesGrupos
grupos
usuarios
grupos
documento
documentos
selgrupo
REVOCAR_PERMISOS
ASIGNAR_PERMISOS
asignarPermiso
cancelar
gruposPermiso
gruposScroll
revocarPermiso
seleccionGrupos
usuariosPermiso
usuariosPermitidosSeparator
usuariosScroll
= new Cuentas()
+ <<Constructor>> Notificaciones ()
+ <<Constructor>> Notificaciones (Documento documento)
+
notificarSolicitudCambioDocumento (Usuar : void
io solicitante, Usuario notificado,
Documento documento, String nota,
int tipo)
utilidadGrupos
PermisosUsuariosDocumento
*
*
*
*
*
+
+
-
*
*
*
-
Notificaciones
(business)
Grupos
(business)
* sesionAbierta : Session
+ getGrupoById (int grupoId)
: Grupo
+ getGruposList ()
: DefaultListModel<String>
+ getUsuariosGrupo (Grupo grupo)
: DefaultListModel<String>
+ getGruposEnSistema ()
: DefaultTableModel
+ guardarGrupo (Grupo grupoAcrear) : void
+ crearSesion ()
: void
+ abrirSesion ()
: void
+ cerrarSesion ()
: void
+ setUsuariosGrupo (Grupo grupo,
: void
HashSet<Usuario> usuariosGrupo)
String
void
Usuario
void
String
void
String
void
String
void
boolean
void
boolean
void
String
void
: boolean
: void
: String
: void
: String
: void
: boolean
: void
: Date
: void
: Date
: void
Figura 19 Diagrama visual
Diagrama del paquete
Descripción COM INTEGRAITEC DOCBPM VISUAL
18/10/2012
Fecha
Autor/Fuente Gustavo Justicia Lucia Del Pino
Titulo
5 4 Desarrollo de prototipo
86
: int
: void
: Perfil
: void
: Grupo
: void
: String
: void
: String
: void
: String
: void
: String
: void
: String
: void
: Date
: void
: Date
: void
: boolean
: void
: boolean
: void
: byte[]
: void
: String
: void
: Set
: void
: Set
: void
: Set
: void
: Set
: void
: Set
: void
El objetivo del prototipo es visualizar la habilidad del consultor en la utilización de la
herramienta de control de documentos, que permita:
-
Establecer la relación de cliente – programa
-
Definir componentes básicos, tales como administración de usuarios, actividades,
permisos y procesos.
-
Autentificación de usuarios
Los gráficos que se presentan a continuación son extraídos directamente del sistema.
El sistema será instalado con la clave de administrador por default, la cual podrá ser cambiada por
el encargado del sistema, que deberá crear los respectivos usuarios del sistema. Para conectar al
programa se deberá ingresar Nombre y contraseña antes ya asignadas por el encargado del sistema
posterior a este proceso los usuarios podrán actualizar sus contraseñas para un nuevo ingreso.
-
Mensaje de bienvenida
El mensaje de bienvenido corresponde al
nombre del usuario el cual esta validado al
ingreso, en este espacio de la pantalla, también
procederá a
salir las notificaciones
de los
documentos pendientes por el respectivo
usuario.
87
-Pantalla principal de inicio
La pantalla de inicio muestra los siguientes componentes:
Principal: En el link de principal tendrá la opción de cerrar sesión y bloquear
terminal.
Escritorio: Para un mejor ambiente habrá la posibilidad de cambiar el fondo de pantalla
del programa como presenta a continuación.
88
Mi Cuenta: El usuario tendrá la opción de poder cambiar la información básica, y el
mail, mas no la información del cargo de empresa, grupo al cual pertenece, la primera
vez que ingrese deberá actualizar el mail con la contraseña del mismo para poder enviar
mails de notificaciones a los diferentes usuarios del sistema.
Datos generales:
-
User Name: Nombre de usuario completo.
-
Pasword: Este campo nos sirve para cambiar la contraseña en caso sea necesario
-
Repetir Pasword: Ingresamos la contraseña nueva a la cual se aplicará en los nuevos
ingresos
-
Firma: La firma de la persona consiste entre 3 y 4 letras las cuales serán únicas para
cada empleado.
89
-
Datos Personales
-
Nombre: Nombre o nombres de empleado
-
Apellido: Apellido o apellidos del empleado
-
Cargo: Cargo el cual consta en el contrato de cada empleado.
-
Estado: Estado actual de cada empleado
-
Perfil: Perfil de usuario
-
Grupo de usuario: Áreas de personal
Accesos directos de los siguientes componentes
-
Notificaciones
-
Procesos de Negocio
-
Documentos y control
-
Gestión de cambios
-
Usuarios y perfiles
Notificaciones
90
Al dar click en el botón de Notificaciones se despliega la pantalla de notificaciones la
cual nos presenta la siguiente información:
-
Estado: En el estado
-
Enviado por: La persona la cual envió el requerimiento
-
Notificaciones: Titulo del requerimiento
-
Fecha de Envío: Fecha en la cual se envió el requerimiento
-
Posteriormente en el cuadro blanco se presentara el detalle completo del requerimiento
el cual ha sido enviado para el usuario.
Procesos de negocio- DocBPM
En los procesos del negocio se procedera a ingresar todos los procedimientos los cuales son
utilizados en LOGICA y sus respectivos sub procedimientos
Detalles principales de proceso:
91
-
Proceso: Nombre del procedimiento o identificador del procedimiento
-
Nivel: nivel de procedimiento, indica si es sub procedimiento o procedimiento principal
-
Documentos: en la parte de documentos presenta el nombre de todos los documentos
los cuales están relacionados al proceso ingresado.
-
Procesos relacionados: Mientras el padre del procedimiento en caso de tener, si no se
presenta en blanco tal como en la figura
Subir el documento del proceso.
La opción de subir el diagrama de flujo del proceso el cual se realiza en lógica o incluir los
pasos del proceso, en caso de ser dos documentos, se los comprime en un archivo .zip o .rar
y se sube en la parte de diagrama
Al subir el proceso en el sistema se guarda automáticamente en la base de datos con la
respectiva información.
-
Documentos y control
92
Al dar click en Documentos y control tenemos la barra de accesos directos en la parte de
arriba la cual consiste en los siguientes ítems:
LMD: Lista maestra de documentos.
La pantalla de la lista maestra de documento nos muestra la siguiente información la cual es
indispensable en el momento de control de documentos:
-
ID: Identificación del documento la cual se llena automáticamente al subir el
documento
-
Documento: Nombre del documento.
-
Creador: Nombre del creador del documento ( el programa toma automáticamente el
nombre del usuario el cual ha realizado el documento y lo ha subido en la LMD)
-
Fecha de creación: Es el día en el cual el usuario subió el documento para ser revisado
por el encargado de revisar el documento.
-
Revisor: Nombre de la persona la cual reviso el documento,
93
-
Fecha revisado: Fecha la cual el documento ha sido revisado por el encargado.
-
Aprobador: Nombre de la persona la cual aprobó el documento.
-
Fecha de aprobación: fecha de a aprobación del documento
-
Fecha de entrega: Fecha tentativa de entrega del documento, la cual fue ingresada al
mandar a crear el documento.
-
Versión/revisión: Versión del documento
-
Versión Máxima: Numero de versiones que puede tener el documento.
-
Tipo: Tipo de documento (externo o interno).
-
Proceso: Proceso al cual está relacionado el documento.
Documentos por subir
El usuario tendrá la pestaña de Documentos por subir la cual informa al usuario los
documentos pendientes, el sistema presenta la siguiente información del documento:
-
ID: Identificación del usuario la cual se crea automáticamente al momento de mandar a
crear el documento.
94
-
Documento: Nombre del documento asignado por el usuario que mandó a crear el
documento.
-
Fecha de entrega: fecha de entrega.
-
Versión/Revisión: Número de versión del documento
-
Tipo: Tipo de documento
-
Proceso: Nombre del proceso al cual está ligado el documento
Documentos por revisar:
Los usuarios del sistema los cuales tendrán documentos pendientes por revisar tienen la
opción de ver en la pestaña de documentos por revisar la lista de documentos, luego de
revisar completamente el documento el usuario tiene la opción de marcar como revisado, al
instante que el revisor ha marcado revisado el documento pasa automáticamente a la lista de
documentos por aprobar.
Información básica de documentos por revisar:
-
ID: Identificador del documento
-
Preparador: Nombre de la persona que realizo el documento
95
-
Documento: Nombre del documento
-
Fecha de entrega: Fecha Tentativa de entrega
-
Versión/ revisión: Numero de versión
-
Tipo: Tipo de documento
-
Proceso: Nombre del proceso al cual esta ligado
-
… : Estado del documento( se podrá marcar revisado )
Documentos por aprobar
Los documentos por aprobar podrán ser monitoreados puesto que se despliega la lista de
todos los documentos los cuales han pasado por la revisión y listo para su aprobación en
caso que haya algún cambio tendrán que ingresar por medio de gestión de cambios, de otro
modo se procederá a la aprobación del mismo.
Datos básicos de documentos por aprobar
-
ID: Identificación del documento
-
Preparador: Nombre del usuario que elaboro el documento.
96
-
Revisor: Nombre del revisto:
-
Documento: Nombre del documento.
-
Fecha de entrega: Fecha de entrega tentativa
-
Versión/ Revisión: Numero de versión del documento
-
Tipo: Tipo de documento
-
Proceso: Nombre del proceso al cual está ligado el documento
-
… : Marcar aprobado el documento
Delegar Creación
La delegación de creación de documentos comprende de una pantalla la cual nos pide la
siguiente información
-
Usuario seleccionado para la creación: En la lista
de usuarios se selecciona
encargado de realizar la creación del documento al dar click en el botón
-
el
.
Usuario seleccionado para la revisar: Seleccionamos el usuario el cual se ha designado
para revisar el documento
97
-
Usuario seleccionado para aprobar: Seleccionamos de la lista de usuarios el que vaya
aprobar dicho documento, en caso de ser la misma persona que revisa se procede a dar
click en el botón de copiar revisor.
-
Nombre de documento : Nombre del documento con el cual se le identificara en la lista
maestra de documento
-
Documento es versionable: Marcamos la casilla si el documento podrá tener varias
versiones en caso contrario será único.
-
Fecha de entrega: Fecha tentativa de entrega del documento.
-
Agregar descripción al documento: mediante este botón tenemos la opción de agregar
indicaciones detalles, notas observaciones del documento.
Al finalizar de ingresar los datos del documento el cual será realizado automáticamente manda las
notificaciones a los usuarios involucrados mientras se realiza todo el proceso tenemos la pantalla de
espera la cual se muestra a continuación
Gestión de cambios- DocBPM
La gestión de cambios consta de dos grupos los cuales son:
-
Solicitud de usuarios
-
Solicitud de documentos
98
Para la solicitud de usuarios tenemos:

Creación de usuarios

Modificación de usuarios

Eliminación de usuarios
Las administraciones se manejan de la siguiente forma
Entrada: Escribimos el nombre de la persona que desea solicitar la creación/ cambio/
eliminación
99
Solicitud: La solicitud se ingresa textualmente en la pantalla que aparecerá a
continuación.
Usuarios: Se seleccionara los usuarios los cuales necesitan saber de los cambios /
modificación / eliminación que ser realizara.
Usuarios y credenciales DocBPM
100
En los usuarios y credenciales tenemos la clasificación de las personas ingresadas en
el sistema por lo que se determina en tres grupos los cuales son
-
Usuarios.
-
Grupos
-
Perfiles
El prototipo del programa consta con los botones básicos en toda su aplicación los
cuales son
-
Aceptar
-
Actualizar
-
Cancelar
-
Borrar
5.1.1. Riesgos
El riesgo afecta a los futuros acontecimientos del desarrollo o implementación del
programa. Por lo que el análisis de riesgo es importante ya que nos hacemos
preguntas básicas tales como que riesgos podrían hacer que nuestro proyecto
fracasara, como afectaran los cambios en los requisitos del cliente, con el profundo
análisis de estas dos preguntas creamos la tabla de riesgos la cual especificara la
solución para que el proyecto esté parcialmente sin errores.
En la siguiente tabla especificamos los posibles riesgos y el control asociado, del
programa de control de documento los cuales hemos podido ver en el transcurso del
análisis.
101
No
1
2
Caso
Riesgos
Configurar el programa en red a
todos los miembros de la
empresa LOGICA
Suplantación de identidad
(spoofing)
Denegación de servicio
Puntos de acceso Wlan mal
intencionados
Se limite a la disponibilidad
de la información
No existe una política de respaldo
de información la cual sea
administrada por el encargado del
sistema
Comprometer la integridad
de la información
Impacto
Tipo de
impacto
Causas
4
Falta de conocimiento por parte
del usuario del sistema.
Reingeniería de los procesos
Retraso en los proyectos
Levantamiento de "no
conformidades"
Déficit en la gestión de
calidad
Dificultad de la gestión de
proyectos
Colapso en la empresa
5
Información a terceros de la
clave de la base de datos
Motor de base de datos
Titulo
Descripción
Fecha
Autor/Fuente
Probabilidad
ocurrencia
Con estos riesgos
puede haber
demoras en la
Media
implementación del
programa de control
de documentos
Falta de
comunicación con
la persona
encargada del
sistema LAN, falta
de coordinación
Coordinación de
fechas para
implementación,
Bajo
capacitación y
creación de
usuarios
Falta de confianza
por parte de los
clientes al no
encontrar
información
respaldada
Alto
Falta de
comunicación con
el encargado del
sistema
Proponer una
politica de
respaldo la cual
podría ser
ejecutada una
vez por mes
Medio
Falta de
capacitación a todo
el personal de la
empresa
Asegurar que la
capacitación esté
completamente
Medio
clara para todos
los usuarios del
sistema
Bajo
Reuniones para
Mal levantamiento
la coordinación
de los
del
requerimientos del
levantamiento
sistema
del sistema
Alto
Falta de seriedad
por parte del
encargado de
sistemas
Mala manipulación de alertas
3
Control
asociado
Retraso en la
obtención de la
certificación
9001:2008
Retraso en la
entrega del
producto, falta de
conocimiento de la
reingeniería
Manipulación
manual la base de
datos
Medio
Medio
Carta de
confidencialidad
Medio
del encargado
del sistema
Tabla 1.2 Riesgos
Tabla de análisis de riesgos.
18/10/2012
Gustavo Justicia, Lucia Del Pino
5.2. Fase de construcción
5.2.1. Implementación
Para la implementación se optó por mantener una solución de método paralelo.
El Método Paralelo permite que los sistemas de información antiguo y nuevo
operen juntos hasta que el nuevo demuestra ser confiable y, lo que conlleva a ser un
método de bajo riesgo. En el caso de una falla en el nuevo sistema, la compañía
puede seguir haciendo uso del sistema anterior hasta corregir las fallas del nuevo
sistema. Aunque, por otra parte este método puede significar ser de un costo mayor
de mantenimiento para la compañía debido a la coexistencia de ambos sistemas, sin
102
embargo, para la empresa LOGICA, esto no conlleva a un riesgo que impacte en la
economía general de la compañía ya que el enfoque y alcance de la aplicación no es
de alta complejidad, asimismo como el mantenimiento actual de la manera en la que
se lleva el control de documentos en la empresa.
La implementación de un nuevo sistema de control de documentos en la empresa
LOGICA es una situación la cual debe ser discutida de manera detallada con los
participantes, dueños y responsables del proceso de control de documentos, debido
a que no sabemos el impacto que pueda tener el nuevo sistema en los integrantes de
la empresa, hay que tomar en cuenta que no todas las personas se adaptan
fácilmente al cambio. Debido a esto se mantuvieron reuniones entre la alta
dirección de la empresa para determinar el mejor camino para la implementación
general del sistema.
La capacitación personal fue discutida con la compañía, llegando a determinar los
participantes así como su grado de participación en las actividades, dando a lugar la
delegación de un encargado del sistema, en este caso será el administrador de
calidad, comenzando desde los conceptos más básicos del programa. Luego se
capacitará directamente a los integrantes de la empresa explicando detalladamente,
la navegación por el mismo, por sus menús, funciones, características.
5.2.2. Pruebas
Los tipos de pruebas realizadas fueron, black-box (caja negra) puesto que este tipo
de pruebas se acoplan perfectamente para la metodología de desarrollo de software
utilizada.
103
Al desarrollar pruebas de caja negra, se logra definir pruebas de alto nivel sin entrar
en temas técnicos complejos los cuales podrían llevar mucho tiempo en ser
entendidos por los usuarios finales del sistema.
5.2.2.1. Nivel de Pruebas
Después de analizar la situación actual de LOGICA optamos por pruebas de
integración puesto que con ellas podríamos dar un seguimiento continuo de los pasos.
Las pruebas de integración tienen por objetivo verificar funcionamiento en conjunto
de dos o más módulos, se deben poner en práctica desde la creación de dos módulos
que interactúen entre sí, en el supuesto caso que se necesiten más de dos módulos para
efectuar las pruebas, deberán generarse simples emuladores de módulos que entreguen
datos esperados para la prueba individual de cada uno.
Las pruebas de integración pueden ser realizadas en forma ascendente, esto evita tener
que crear módulos emuladores, ya que a medida que se va creando la pirámide va
siendo probada de abajo hacia arriba (Es decir, prueba un conjunto amplio de
componentes del sistema, para posteriormente al realizar las pruebas en un nivel
superior se cubra lo realizado como parte de una prueba anterior), esto acarrea un
trabajo simétricamente mayor lo que equipara o supera el tiempo que podría tomar el
crear módulos para prueba.
Luego de las pruebas de integración realizadas en LOGICA con la colaboración de la
Gerente General se ha logrado corregir los errores los cuales se han encontrado al
transcurso de las pruebas teniendo como un resultado la funcionalidad correcta del
programa, actualmente se continúa con algunas pruebas de los módulos, obteniendo
resultados exitosos sin generarse ningún tipo de error
Las pruebas realizadas se encuentran documentadas como parte del Anexo.
104
5.2.3. Fase de transición
5.2.3.1. Seguridades
La seguridad del sistema se ha implementado mediante la creación del rol
administrador de seguridad, definido en la fase del análisis de requerimientos. En el
caso específico de la empresa LOGICA, el Administrador de Calidad es el
responsable de asumir este rol, de esta manera, acabado el desarrollo de la aplicación
se logra mantener un alto nivel de integridad y confiabilidad de los datos, ya que la
manipulación de ellos se ve limitada por terceras personas, reduciendo la suplantación
de identidad o creación o bloqueos de usuarios no autorizados.
Al mantener diferentes tipos de roles y perfiles dentro de la aplicación logramos
reforzar la seguridad de la información debido a que existe una debida segregación de
funciones entre el personal de la compañía y que hace uso de el sistema desarrollado.
Como parte adicional a la seguridad se pensó en la implementación de Single-Sign On
para los usuarios de este sistema es decir, el usuario es capaz de ingresar directamente
al sistema el cual validará su sesión de Windows y le permitirá ingresar de manera
automática con las credenciales pertenecientes a ese usuario. Cabe mencionar que, a
pesar de ser una opción beneficiosa al momento de realizar el ingreso al sistema por
parte del usuario, es de responsabilidad de los encargados de la seguridad de la
información de la compañía mantener políticas y procedimientos que permitan mitigar
riesgos relacionados al mal uso de contraseñas o, estaciones de trabajo.
5.2.3.2. Despliegue
Para el despliegue de la aplicación se utilizó el servidor instalado en la empresa
LOGICA, HP, se realizó la debida instalación y generación de la instancia del motor
105
de base de datos MySQL 5.3 para soportar la base de datos de la aplicación. Los
archivos compilados correspondientes al sistema se encuentran debidamente
instalados en una carpeta del servidor a la cual tienen acceso de lectura únicamente
los usuarios identificados por parte del administrador de seguridad, en el caso de
LOGICA el administrador de la calidad es el encargado de definir los usuarios que
tendrán acceso al sistema y, a la carpeta del servidor en cuestión.
5.2.3.3. Mantenimiento
El sistema al ser un desarrollo multicapa, permite la fácil integración y modificación
de módulos de acuerdo a lo que necesite la compañía, cualquier modificación en el
modelo de base de datos podrá ser fácilmente reflejada y mapeada a un modelo
orientado a objetos con la manipulación del archivo de configuración de Hibernate
con el cual se podrá generar de manera muy simple el POJO que corresponda a la
entidad de base de datos. Es importante mencionar que se deberá mantener una
política de respaldos para evitar cualquier pérdida de integridad o disponibilidad de la
información. Esta tarea deberá ser de responsabilidad de la empresa LOGICA.
106
CAPÍTULO VI
CONCLUSIONES Y RECOMENDACIONES
6.1. Conclusiones
1.
La norma ISO 9001:2008 exige que los documentos sean aprobados, revisados y
actualizados a fin de mantener control sobre los mismos, sin embargo no especifica si
el control debe hacerse de forma manual o mediante una herramienta tecnológica.
2.
La empresa debe identificar los cambios, el estado de versión vigente y asegurarse
de que las versiones pertinentes se encuentren disponibles, a fin de que los usuarios al
momento de realizar sus funciones tengan las herramientas adecuadas y oportunas.
3.
Una vez evaluado la situación de la empresa se ha concluido que existe un control
débil de la documentación, con la utilización de la herramienta propuesta se cumplirá
con todas las exigencias de la norma ISO 9001:2008.
4.
La determinación y diagramación del proceso de control de documentos permitió
obtener un entendimiento más claro de las funcionalidades que se requerirían para el
desarrollo del sistema, el cual permitió la automatización del proceso de control de
documentos.
5.
La metodología RAD permitió desarrollar la aplicación en conjunto con el usuario
final, obteniendo resultados funcionales de un grado de satisfacción mayor que el que
se hubiera obtenido al realizar el uso de una metodología en la cual el usuario no se
encuentre involucrado activamente en el desarrollo de la funcionalidad del sistema
final.
6.
Para el desarrollo de la aplicación de control de documentos se ha alineado a lo que
dice estrictamente la norma y que incluye la segregación de funciones entre el
personal de la empresa que realiza, revisa, aprueba los documentos. Así como
107
también el personal el cual se encuentra permitido visualizar los documentos y el
correcto resguardo de su repositorio de datos.
7.
Con el programa de control de documentos hemos optimizado el tiempo de control de
documentos en un setenta por ciento.
8.
El desarrollo de la aplicación fue exitoso puesto que fue de fácil integración con la
empresa LOGICA, debido a que el enfoque de realización del proyecto estaba
orientado a una pequeña empresa la cual necesite una solución ágil y adicionalmente,
debido a que el personal clave de la empresa participó activamente en el desarrollo de
las funcionalidades del sistema.
9.
Los diagramas de clases ayudaron a un desarrollo de la aplicación mucho más
ordenado y rápido permitiéndonos visualizar la extensión total y la cantidad de
recursos necesarios para la realización y finalización del proyecto en cuanto a
cantidad de codificación a realizar y relaciones entre las diferentes clases del sistema
para una óptima re-utilización de recursos, propósito fundamental en el desarrollo
bajo una metodología RAD.
10. Se ha fortalecido el desarrollar software basándose en una norma internacional,
además de tener contacto continuo con nuestro cliente.
6.2. Recomendaciones
1.
Se deben establecer responsables para la elaboración, revisión, y aprobación de los
documentos conforme a los requerimientos de la norma ISO 9001:2008 y asignar su
rol respectivo.
2.
Mantener como política de la empresa la utilización de la herramienta a fin de que los
documentos sigan un flujo adecuado y de esta manera cumplir con el requerimiento
de la norma ISO 9001:2008.
108
3.
El mantenimiento de la aplicación es un punto esencial por lo que debe haber un
encargado el cual monitoree el almacenamiento en la base de datos. Así como
también el respaldo oportuno de los datos en caso de que exista algún inconveniente
que ponga en riesgo la integridad de la información almacenada.
4.
Si bien el tener una aplicación que permita el control de documentos, no se debe
perder la comunicación entre los miembros del equipo de trabajo
5.
Utilizar el programa continuamente en la actualización de la base para que los
usuarios del sistema se familiaricen de una manera fácil.
6.
Gestionar un mayor número de perfiles que puedan permitir entregar una mayor
flexibilidad al momento de asignar funciones al personal de la compañía y que vayan
a formar parte de los usuarios finales de la aplicación.
7.
La utilización de una metodología RAD debe ser cuidadosamente analizada, ya que
esta metodología si bien es cierto, permite un desarrollo acelerado de aplicaciones;
existen inconvenientes cuando la aplicación necesita de una personalización mucho
más detallada y, que requiera de una mayor complejidad al momento de evaluar la
calidad final de las funcionalidades determinadas al momento de realizar el análisis
de requerimientos
8.
Subir todos los documentos de la empresa con todo el detalle del mismo.
9.
La utilización de las herramientas debe ser analizada en cuanto a presupuesto
disponible de la empresa para la inversión de estos recursos, al igual que las
necesidades reales y proyectadas que pueda beneficiar a la empresa sin reducir la
calidad ni desempeño de la aplicación en un ambiente de producción.
10. Realizar actualizaciones de la herramienta diseñada, en la medida en que la Norma
ISO9001 2008 sea actualizada.
7.
Bibliografía
109
7.1. Libros
-
Spring Persistence with Hibernate (Beginning)
Paul Tepper Fisher (Author), Brian D. Murphy (Author)
-
NetBeans IDE 7 Cookbook
Rhawi Dantas (Author)
-
High Performance MySQL: Optimization, Backups, and Replication by Baron
Schwartz,
Peter Zaitsev and Vadim Tkachenko (Mar 30, 2012)
7.2. Internet
-
http://es.wikipedia.org/wiki/Metodolog%C3%ADa_de_desarrollo_de_software
-
http://ocw.uoc.edu/computer-science-technology-and-multimedia/bases-de-datos/basesde-datos/P06_M2109_02151.pdf
-
http://www.adictosaltrabajo.com/tutoriales/tutoriales.php?pagina=hibernate
-
http://www.logica.com.ec/
-
http://www.logica.com.ec/mapa-del-sitio-4.html
-
http://www.logica.com.ec/acerca-de-logica.html
-
semiconductores-posgrado.mx/Calidad/NORMA_ISO_9001_2008.pdf
-
www.mx.sgs.com/es_mx/iso_9001_2008-2?serviceId=10954
-
http://www.utpl.edu.ec/iso9001/images/stories/PROCEDIMIENTO_CONTROL_DOC
UMENTOS.pdf
-
gestion-y-calidad.blogspot.com/2009/02/iso-90012008.html
-
http://docs.kde.org/stable/es/kdesdk/umbrello/uml-elements.html
110
111