UNIVERSIDAD NACIONAL ABIERTA
VICERRECTORADO ACADÉMICO
ÁREA DE INGENIERÍA
CARRERA INGENIERÍA DE SISTEMAS
IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE
LA PROGRAMACIÓN ORIENTADA A ASPECTOS
Autor: Carlos Córdova, C.I.: 8.441.858
Tutor Académico: Ing. Rafael Caldera, C.I.: 7.122.533
Asesor Empresarial: Lic. Ana Fuentes, C.I.: 12.666.425
Cumaná, Centro Local Sucre (17)
Enero, 2007
ii
ÍNDICE DE CONTENIDO
Pág.
AGRADECIMIENTO …..…............................................................................
iii
DEDICATORIA ………....................................................................................
iv
ÍNDICE DE CONTENIDO ..............................................................................
v
RESUMEN .........................................................................................................
viii
INTRODUCCIÓN ............................................................................................. ix
CAPÍTULO I:
El problema
I.1.
Antecedentes del problema ..................................................................... 1
I.2.
Planteamiento del problema ................................................................... 2
I.3.
Objetivo general ……….………............................................................. 4
I.4.
Objetivos específicos .............................................................................. 4
I.5.
Estudio de factibilidad ……………………………………………….... 5
I.6.
Limitaciones y alcance ……………………………………………….... 6
I.7.
Justificación …..……….………............................................................. 7
CAPÍTULO II:
Marco teórico
II.1.
Ingeniería de Software …………………................................................ 8
II.2.
Ingeniería de Requisitos …………………............................................. 9
II.3.
Desarrollo de Software Orientado a Objetos (POO) ….......................... 16
II.4.
Programación Orientada a Objetos (POO) ............................................. 17
II.5.
Desarrollo de Software Orientado a Aspectos (DSOA) ......................... 20
II.5.1 Objetivo principal de DSOA ….………….………………….… 20
II.5.2 Breve reseña histórica ……….………….……..…………….… 21
II.5.3 La separación de incumbencias ………………..…………….… 23
II.5.4 Ventajas de la separación de incumbencias ……………………. 25
iii
II.5.5 Tiranía de la Descomposición dominante …..……………….… 26
II.5.6 Incumbencias Transversales …….……………..…………….… 27
II.5.7 Alternativas de Solución …………………………………….… 28
II.6.
Programación Orientada a Aspectos (POA) ........................................... 29
II.6.1 Terminología Básica ….………….………………………….… 30
II.6.2 Fundamentos de la Programación Orientada a Aspectos ……… 35
II.6.3 Lenguajes Orientados a Aspectos ……………………………… 36
II.6.3.1 Lenguajes de Aspectos de Dominio Específico …….… 37
II.6.3.2 Lenguajes de Aspectos de Propósito General ………… 38
CAPÍTULO III:
Marco metodológico
III.1. Tipo de investigación ............................................................................. 40
III.2. Nivel de la investigación ........................................................................ 40
III.3. Fuentes y técnicas de recolección de información ................................. 40
III.4. Metodología: Análisis y Diseño de Sistemas Orientado a Objetos
usando el Lenguaje Unificado de Modelación (UML) .......................... 41
III.5. Conceptos y diagramas de UML ………................................................ 43
CAPÍTULO IV:
Resultados
IV.1. Análisis de conceptos y definiciones del DSOA y de la POA ............... 47
IV.2. Implementación de la plataforma tecnológica …………….................... 51
IV.2.1
Instalación del lenguaje base (Java) …..……………..…….… 54
IV.2.2
Instalación del lenguaje de aspectos (AspectJ) …..…..……… 57
IV.3. Diseño del caso de estudio ….………………………………………… 61
IV.4. Solución al caso de estudio ……………………..………..…………… 64
IV.4.1
Investigación preliminar ……………...……………..…….… 64
IV.4.2
Requerimientos del sistema …………...……………..…….… 65
iv
IV.4.2.1
Requisitos funcionales ………………………………… 66
IV.4.2.2
Requisitos no funcionales ………..…………………… 67
IV.4.2.3
Requisitos funcionales vs. Requisitos no funcionales … 68
IV.4.3
Diseño del sistema …………………...……………...….….… 69
IV.4.3.1
Modelo de caso de uso ………………..……….……… 69
IV.4.3.2
Diagrama de clases ………………………….………… 70
IV.4.3.3
Diagrama de secuencia …………….……….……….… 71
IV.4.3.4
Diagrama de actividades …………………………….… 72
IV.4.3.5
Especificación de requisitos no funcionales ……..….… 73
IV.4.4
Desarrollo del software ………………...………..……..….… 76
IV.4.4.1
Construcción de la base de datos ….……………..…… 81
IV.4.4.2
Construcción del código base (clases)….…….…..…… 85
IV.4.4.3
Construcción del aspecto (requisitos no funcionales) … 86
IV.4.5 Prueba e implementación …………………………………….. 87
IV.4.5.1
Empaquetado e instalación del código base y aspecto … 87
IV.4.5.2
Creación del origen de datos …..………….……...…… 89
IV.4.5.3
Compilación y ejecución del código base …….…..…… 92
IV.4.5.4
Compilación y ejecución del código base y aspecto …... 94
IV.4.5.5
Comparación sistema base con sistema aspectual …..… 97
IV.4.6. Documentación …………………...…….……………..……… 100
Conclusiones ……............................................................................................... 101
Recomendaciones …........................................................................................... 102
Glosario ……....…............................................................................................... 103
Bibliografía …..…............................................................................................... 107
Anexos …..…....................................................................................................... 112
5
RESUMEN
Este trabajo consiste en la Implementación de Requisitos no Funcionales a
través de la Programación Orientada a Aspectos (POA) en un Sistema de Software.
De manera general, los requisitos funcionales capturan el comportamiento deseado
del sistema y pueden ser expresados como servicios o funciones; mientras los
requisitos no funcionales tales como: seguridad, disponibilidad, respuesta en tiempo
entre otros, especifican las condiciones que debe satisfacer el sistema, restringiendo,
condicionando o controlando la ejecución de los requisitos funcionales. Estos
requisitos no funcionales asociados generalmente a propiedades de calidad del
software y que en muchos casos se diseminan y entrecruzan con la funcionalidad
principal, dificultando su entendimiento, mantenimiento y reutilización, son
conocidos como incumbencias transversales o concerns transversales (“crosscutting
concerns”), dentro del emergente paradigma del Desarrollo de Software Orientado a
Aspectos (“Aspect-Oriented Software Development”, AOSD). Las técnicas utilizadas
en DSOA, se aperturan a partir de las investigaciones y aplicaciones de la POA, y
hacen esto posible al modularizar los aspectos transversales de un sistema de
software. La POA, surge tratando de solucionar dos problemas detectados durante el
proceso de desarrollo de software: el enmarañamiento del código y el hecho de que
determinados conceptos no se localizaban bien con la programación orientada a
objetos, sino que se esparcían entre distintas clases.
La POA, no está consolidada en la comunidad de la ingeniería de software,
actualmente profesionales de la academia y la industria realizan grandes inversiones,
a fin de poner a disposición los adelantos técnicos que permitan transitar hacia la
eficientemente adopción de este paradigma. La aceptación de un nuevo enfoque debe
pasar por la exploración y dominio de las tecnologías inherentes al mismo, al cual
deben incorporarse las Universidades y centros de investigación del país a fin de
apalancar su propio desarrollo tecnológico y contribuir activamente al desarrollo de
nuevas tecnologías.
En primer término se hizo un estudio, análisis y prueba de las tecnologías
inherentes referenciadas por diferentes autores para la aplicación de la POA. En este
estudio se comprobó que los requisitos no funcionales pueden ser manejados como
concerns transversales y los mismos ser implementados a través de la POA. Para
probar esto fue necesario el estudio e implantación de la plataforma tecnológica para
la POA, desarrollar un caso de estudio compuesto por un sistema base y aspecto. Se
aplicó la POA a través del caso de estudio para generar el sistema aspectual y
finalmente se establecieron las conclusiones y recomendaciones producto de los
resultados de la investigación.
Palabras claves: Programación Orientada a Aspectos, POA, DSOA, concerns,
crosscutting concerns, aspecto, pointcut, joint point, advises.
6
INTRODUCCIÓN
Desde sus comienzos, el desarrollo de software ha estado en constante
evolución, y en las últimas décadas han surgido varios paradigmas de programación
que han contribuido a hacerlo más eficiente. Cada etapa de la evolución se vio
marcada por nuevos enfoques para ayudar a los desarrolladores a manejar programas
cada vez más complejos. Los primeros programas se crearon mediante procesos a
través de conmutadores ubicados en el panel frontal de la computadora. Este enfoque
sólo era adecuado para programas pequeños. Seguidamente se inventó el lenguaje
ensamblador que permitió escribir programas más largos, luego otro avance
importante ocurrió en los años 50 cuando se inventó el primer lenguaje de alto nivel
(FORTRAN) [9].
Con los lenguajes de alto nivel, un programador estaba capacitado para
escribir programas con una longitud de varios de miles de líneas; sin embargo, este
enfoque presentaba el inconveniente de tener un código ilegible y difícil de tratar que
se convertía en “código espagueti”. La eliminación del “código espagueti” se
consiguió con la creación de los lenguajes de programación estructurados en los años
sesenta como Algol y Pascal. Con la programación estructurada se hicieron
programas basados en estructuras de control bien definidas, bloques de código, la
ausencia (o mínimo uso) de la instrucción GOTO, y subrutinas independientes que
soportan recursividad y variables locales [9].
Aunque la programación estructurada ha obtenido excelentes resultados
cuando se aplica a programas moderadamente complejos, nuevos enfoques que
promueven la reutilización futura, reducción de posteriores errores y futuro
mantenimiento han aperturado la evolución hacia nuevos paradigmas. A partir de este
punto surge la Programación Orientada a Objetos (POO), con lenguajes como
vii
ideas incorporadas en la programación estructurada y las combina con nuevos y
potentes conceptos que permiten organizar los programas de forma más efectiva. La
POO permite descomponer un problema en subgrupos relacionados. Cada subgrupo
pasa a ser un objeto que contiene sus propias instrucciones y datos, de esta manera la
complejidad se reduce y el programador puede tratar programas más largos. Este
enfoque cuyas principales características son el encapsulamiento, el polimorfismo y
la herencia y cuyos objetivos son la abstracción, la modularidad y la reusabilidad, se
consolidó hasta hoy como el último paradigma en el desarrollo de software [9] [10].
En este contexto y en la búsqueda de resolver múltiples dificultades
presentadas durante el ciclo de vida de desarrollo de software, han surgido durante
los últimos años nuevas propuestas entre las que se destaca, el enfoque de Desarrollo
de Software Orientado a Aspectos (DSOA) [12]; el cual extiende las técnicas
tradicionales de desarrollo y en particular las orientadas a objetos, permitiendo a los
desarrolladores encapsular en módulos separados las propiedades comunes o áreas de
interés que atraviesan el sistema. Este nuevo paradigma orientado a aspecto surge a
partir de la Programación Orientada a Aspectos (POA) [12].
La POA, es un enfoque de programación presentado a finales de 1996 por
Gregor Kiczales en el Centro de Investigación de XEROX en Palo Alto [28] (Palo
Alto Research Center o PARC), tratando de solucionar el enmarañamiento del código
y la dispersión de conceptos originados en la POO de los sistemas. En particular, la
POA introduce un término denominado “Aspecto” para separar o tratar los diferentes
conceptos o puntos de interés que se distribuyen a lo largo del código. Se dice por
tanto que la POA no rompe con las técnicas de POO, por el contrario las
complementa y extiende [28].
viii
En el desarrollo de sistemas de software, el modelado, el diseño y la
implementación de la funcionalidad básica, recogen aspectos que en muchos casos no
son propios al dominio de la aplicación, pero incrementan su complejidad. Estas
funcionalidades apuntan hacia el cumplimiento de requisitos no funcionales e inciden
sobre la calidad del producto final. Estas incumbencias generalmente delimitan las
condiciones en que el sistema presta servicios a los usuarios y se especifican como
seguridad, tolerancia a fallos, persistencia, eficiencia, entre otras. En muchos casos
estas incumbencias se entrecruzan a la funcionalidad principal, este problema es
referido en la bibliografía como incumbencias transversales (“crosscutting concerns”)
[29], dificultando el mantenimiento y evolución del sistema de software. La POA
plantea la solución al problema de las incumbencias transversales, sin embargo no
está muy claro y definido las tecnologías asociadas a este nuevo paradigma. Ante una
diversidad de posiciones y criterios de parte de la comunidad internacional y nacional
resulta importante resaltar que para lograr el dominio y posterior adopción del
paradigma, se hace necesario estimular estudios tendientes al análisis y desarrollo del
conocimiento tecnológico necesario que gira alrededor de la POA. El objetivo de este
trabajo es estudiar las tecnologías propias a la POA para el tratamiento de requisitos
no funcionales, como un punto de partida que permita consolidar este enfoque como
la nueva generación en la evolución de los sistemas de software.
Este trabajo se encuentra estructurado en cuatro capítulos dispuestos de la
siguiente manera:
CAPÍTULO I: Contiene los antecedentes y el planteamiento del problema, los
objetivos generales y específicos, el estudio de factibilidad, las limitaciones, el
alcance y la justificación.
ix
CAPÍTULO II: Abarca el marco teórico, las definiciones y conceptos más
importantes acerca de la Ingeniería de Software, del DSOA y la POA.
CAPÍTULO III: Se describe el tipo y el nivel de la investigación, las fuentes y
técnicas de recolección de información y la metodología empleada para diseñar el
caso de estudio.
CAPÍTULO IV: Comprende el análisis de los conceptos y definiciones del DSOA y
de la POA, la implementación de la plataforma tecnológica para la POA, el diseño del
caso de estudio, el desarrollo del caso de estudio, la implementación del sistema
aspectual y la descripción y análisis de los resultados obtenidos.
Finalmente se presentan las conclusiones y recomendaciones finales.
1
CAPÍTULO I
EL PROBLEMA
I.1.
Antecedentes del problema
El Desarrollo de Software Orientado a Aspectos (DSOA), es una nueva
disciplina que se origina a partir de los avances y resultados de la Programación
Orientada a Aspectos (POA). Aún antes de que surgiera el concepto de programación
orientada a aspectos, el grupo Demeter [18] había considerado y aplicado ideas
similares. Los trabajos del Grupo Demeter, estaban principalmente enfocados en la
programación adaptativa (PA), la cual puede verse como una instancia temprana de la
POA. El término programación adaptativa se introduce en 1991. La PA constituye un
gran avance dentro de la tecnología de software, basada en el uso de autómatas finitos
y una teoría formal de lenguaje para expresar concisamente y procesar eficientemente
conjuntos de caminos en un grafo arquitectónico, como por ejemplo los diagramas de
clase en el Lenguaje de Modelado Unificado (UML).
Para 1995 dos miembros del grupo Demeter Cristina Lopes y
Walter
Huersch, presentaron un reporte técnico sobre la separación de conceptos, incluyendo
varias técnicas como filtros composicionales y PA para tratar con los conceptos
(incumbencias) que se entrecruzan. Este reporte identificó el tema general de
separación de incumbencias y su implementación y se propuso como uno de los
problemas a resolver en el diseño y desarrollo de software [18].
No fue sino hasta 1995 cuando se publicó la primera definición del concepto
de aspecto, realizada también por el grupo Demeter, y se describía de la siguiente
forma: “Un aspecto es una unidad que se define en términos de información parcial
2
de otras unidades”. Esta definición ha evolucionado desde entonces hasta llegar a la
definición actual, la cual se tratará más adelante.
Cristina Lopes y Karl Lieberherr empezaron a trabajar con Gregor Kickzales y
su grupo. A Lopes y Kickzales no les gustó el nombre “Programación Adaptativa” e
introdujeron un mejor término “Programación Orientada a Aspectos” con su propia
definición y terminología. En la literatura se lo considera a Gregor Kickzales como el
creador de este nuevo paradigma [18].
El DSOA, trata el problema de la separación de incumbencias (concerns) de
un sistema, con el propósito de disminuir la complejidad del software y facilitar
características tales como: evolución, adaptabilidad, comprensibilidad entre otras.
La separación de incumbencias no constituye un concepto novedoso en la
comunidad, fue identificado en la década de los 70 por “E. Dijkstra: Discipline of
Programming”, el cual plantea que un problema dado involucra varias incumbencias
que deben ser identificadas y separadas [21].
I.2.
Planteamiento del problema
La ingeniería del software ha utilizado el principio de la separación de
incumbencias (Separation of Concern) para manejar la complejidad del desarrollo del
software mediante la separación de las funcionalidades principales de la aplicación de
otras partes con un propósito específico (generalmente ortogonales a la funcionalidad
principal); ejemplos de estas son: autenticación, seguridad, rendimiento, persistencia,
entre otras. La aplicación final se construye con el código de las funcionalidades
principales más el código de propósito específico a través de la POA [5].
3
La POA es un paradigma que recién está naciendo, son lenguajes y plataformas
de programación que dan soporte a la separación de aspectos. Se están realizando las
primeras experiencias prácticas para mostrar su aplicabilidad, y obtener datos
empíricos que estimulen la investigación en el tema.
El emergente paradigma de la POA no está consolidado en la comunidad de la
ingeniería de software, actualmente profesionales de la academia y la industria
realizan grandes inversiones, a fin de poner a disposición los adelantos técnicos que
permitan transitar eficientemente hacia la adopción de este paradigma. La aceptación
de un nuevo enfoque debe pasar por la exploración y dominio de las tecnologías
inherentes al mismo, al cual deben incorporarse las Universidades y Centros de
Investigación del país a fin de apalancar su desarrollo tecnológico y contribuir con el
desarrollo del mismo. Los resultados de parte de la comunidad internacional son
diversos y muy variados [5][6][8][12], presentando algunas divergencias entre ellos,
tal vez por la falta de estándares; mientras comienzan a aparecer algunas propuestas
nacionales provenientes de algunas universidades del país [2][3].
Ante esta diversidad de posiciones, tecnologías y criterios resulta importante
resaltar que para lograr el dominio y posterior adopción del paradigma, se hace
necesario estimular estudios tendientes al análisis y desarrollo del conocimiento
tecnológico necesario que gira alrededor de la POA. Por lo antes expuesto y
reconociendo la importancia de la investigación dentro de la formación académica y
humanista, en este trabajo se plantea la implementación de requisitos no funcionales a
través de la programación orientada a aspectos en un sistema de software, como un
punto de partida para el desarrollo del conocimiento e investigación en estas
innovadoras tecnologías.
4
I.3.
Objetivo general
Implementar requisitos no funcionales a través de la programación orientada a
aspectos en un sistema de software.
I.4.
Objetivos específicos
• Analizar los principales conceptos y definiciones del DSOA y de la POA.
• Implementar la plataforma tecnológica para la POA.
• Diseñar el caso de estudio, para definir los requisitos funcionales y no
funcionales del sistema de software.
• Desarrollar el sistema de software para el caso de estudio.
• Implementar los requisitos no funcionales (aspectos) sobre el código base
del sistema de software.
• Elaborar la documentación del sistema de software, documentación del
código base, documentación del aspecto y la documentación para los usuarios del
sistema.
5
I.5. Estudio de factibilidad
Factibilidad Técnica
El desarrollo del proyecto se realizó con la tecnología de hardware y software
que se tenía, asimismo se dispuso del personal capacitado para la elaboración del
mismo. En cuanto a la selección del hardware, el equipo disponible posee las
siguientes características:
• Microcomputador Portátil con procesador Mobile AMD Sempron 3100+
• Disco duro de 40 Gb
• Memoria RAM de 256 Mb DDR
• Unidad lectora de CD-ROM
• Unidad de reescritura CD-WR
• Monitor XGAF TFT LCD 15”
• Mouse de tres teclas
• Puerto inalámbrico para redes 802.1 b/s gíreles LAN
• Impresora de inyección de tinta (dispositivo de salida)
En cuanto a la selección del software, se utilizó el sistema operativo Windows
XP de Microsoft Corporation. Además del sistema operativo, se utilizó para el diseño
de la base de datos el manejador de base de datos Microsoft Access 2003 de
Microsoft Corporation, el lenguaje de programación Java JDK Edition 1.5.0 de Sun
Microsystem Corporation para desarrollar el código base, el lenguaje de propósito
general AspectJ versión 1.5.2 de Xerox Park integrado en Eclipse para la
implementación de los aspectos, el decompilador DJ Java Decompiler 3.6 de Atanas
Neshkov.
6
Factibilidad Económica
La creación de este proyecto no conllevó a grandes gastos económicos, ya que
estuvieron a la disposición los recursos para la elaboración del mismo. Este proyecto
contó con todas las herramientas necesarias para que se pudieran desarrollar los
aspectos generales del caso de estudio, determinar cuáles son sus resultados y
formular las conclusiones y recomendaciones.
Factibilidad Operacional
El recurso humano para desarrollar este proyecto estuvo en la capacidad de
cubrir las etapas de planificación, análisis, diseño y construcción, además de conocer
la parte que involucra la terminología y procedimientos del área en estudio. Por otra
parte los recursos materiales, tanto bibliográficos, electrónicos y técnicos con los
cuales se contó, permitieron la libre investigación del paradigma de la POA y avanzar
en forma acertada en la consecución de los objetivos.
I.6. Limitaciones y alcance
Entre las limitaciones que se presentaron para la elaboración del proyecto, cabe
destacar que el estudio y análisis de las definiciones y conceptos básicos acera de la
POA quedaron sujetos al material bibliográfico y la documentación electrónica de
comprobada autenticidad disponible en la web, así como textos de estudio del autor.
El problema planteado estuvo enmarcado dentro del área de estudio de la Ingeniería
de Requisitos, DSOA y POA, específicamente en el estudio de requisitos funcionales
y no funcionales. El contenido del problema sólo se centró en la implementación de
requisitos no funcionales en un sistema de software a través de la POA. En cuanto al
sistema base que conforma el caso de estudio, se realizó la parte de análisis, diseño y
7
construcción, para finalmente hacer las pruebas e implementación del sistema
aspectual.
I.7.
Justificación
La principal razón para la elaboración de este trabajo es que sus resultados van
a contribuir a la evolución de las actividades tecnológicas y científicas del país en
materia de desarrollo de software, persigue promover el uso de los aspectos a lo largo
de todas las actividades del ciclo de vida del software. El objetivo general la POA es
proponer un proceso de desarrollo de software transparente, donde los diversos
“concerns” o incumbencias que son tratados con aspectos sean el eje central del
desarrollo, desde la ingeniería de requisitos hasta la implementación. Este trabajo
busca comprobar la terminología, los conceptos y el funcionamiento de la tecnología
asociada al paradigma de la POA. Estudiar la posibilidad del tratamiento de los
requisitos no funcionales como potenciales incumbencias transversales sensibles a ser
tratadas a través de la POA. Además es propicio señalar que no existe experiencia a
nivel regional en la Universidad Nacional Abierta que trate este tema.
En la mayoría de los casos, cuando se utilizan enfoques como la Programación
Estructurada o la Programación Orientad a Objetos en la construcción de sistemas de
software, el código se encuentra a menudo diseminado sobre muchas partes de la
aplicación, con el inconveniente de estar enmarañado y disperso. El desarrollo de
tales aplicaciones requiere el uso de técnicas más apropiadas para controlar esta
complejidad adicional y hacer que el software sea más estructurado, más fácil de
entender, mantener y reusar. Es aquí donde la POA interviene como el nuevo
paradigma en la evolución de la ingeniería de software.
CAPÍTULO II
MARCO TEÓRICO
II.1.
Ingeniería de Software
La Ingeniería de software es la rama de la ingeniería que crea y mantiene las
aplicaciones de software aplicando tecnologías y prácticas de las ciencias
computacionales, manejo de proyectos, ingeniería, el ámbito de la aplicación, y otros
campos. La ingeniería de software, como las disciplinas tradicionales de ingeniería,
tiene que ver con el costo y la confiabilidad. Algunas aplicaciones de software
contienen millones de líneas de código que se espera funcionen bien en condiciones
siempre cambiantes [7].
La Ingeniería del Software, término utilizado por primera vez por Fritz Bauer
en la primera conferencia sobre desarrollo de software patrocinada por el Comité de
Ciencias de la OTAN celebrada en Garmisch, Alemania, en octubre de 1968, puede
definirse según Alan Davis como "la aplicación inteligente de principios probados,
técnicas, lenguajes y herramientas para la creación y mantenimiento, dentro de un
coste razonable, de software que satisfaga las necesidades de los usuarios" [31].
El término ingeniería de software se usa con una variedad de significados
diferentes:
• Como el término usual contemporáneo de un amplio rango de actividades
que se solía llamar programación y análisis de sistemas.
9
• Como un término amplio de todos los aspectos de la práctica de la
programación de computadoras, en oposición a la teoría, que es llamada
ciencia computacional o computación.
• La ingeniería de software es (1): “la aplicación de un método sistemático,
disciplinado y cuantificable al desarrollo, operación y mantenimiento de
software, esto es, la aplicación de la ingeniería al software” y (2): “el estudio
de los métodos de (1)”, estándar IEEE (Instituto de Ingenieros Eléctricos y
Electrónicos) [31].
II.2.
Ingeniería de Requisitos
En la ingeniería de requisitos se identifica el propósito del sistema y el contexto
en el que será usado. Los requisitos constituyen el enlace entre las necesidades reales
de los clientes, usuarios y otros participantes vinculados al sistema. La ingeniería de
requisitos consiste en un conjunto de actividades y transformaciones que pretenden
comprender las necesidades de un sistema software y convertir la declaración de estas
necesidades en una descripción completa, precisa y documentada de los
requerimientos del sistema siguiendo un determinado estándar. Se divide en cinco
partes que se corresponden con los cinco tipos de actividades que requiere la
construcción de requisitos: recolección, análisis, especificación, validación y gestión
de requisitos [31].
Recolección de requisitos
Se incluyen los métodos y técnicas para la recolección, el reconocimiento y la
comunicación de los requisitos y restricciones funcionales y no funcionales. Es una
10
actividad más “humana” que técnica. Se identifica a los interesados (stakeholders) y
se establecen las primeras relaciones entre ellos y el equipo de desarrollo.
Requisitos Funcionales: Describen los servicios (funciones) que se esperan del
sistema.
Requisitos No Funcionales: Restricciones sobre los requisitos funcionales. Se
distinguen dos tipos de requisitos no funcionales:
• Orientados al usuario: Fiabilidad, Seguridad (security), Seguridad (safety),
Usabilidad, Robustez, Disponibilidad, Rendimiento (Tiempo de respuesta,
Capacidad, Throughput).
• Orientados
al
desarrollador:
Disponibilidad,
Portabilidad,
Adaptabilidad,
Testabilidad, Comprensibilidad.
Fuentes de Requisitos:
• Metas: Factores críticos de éxito (de la empresa).
• Conocimiento del dominio de la aplicación: Cosas que pueden resultar obvias a los
expertos no lo son para los usuarios.
• Los interesados: Los afectados por el sistema.
• El entorno físico que rodea al sistema.
• El entorno organizacional: Los procesos de negocio.
Problemas de la recolección:
• Los usuarios no pueden/saben describir muchas de sus tareas.
• Mucha información importante no llega a verbalizarse.
11
• A veces hay que “inventar” los requisitos.
• La recolección no debería ser un proceso pasivo, sino cooperativo.
Técnicas de recolección:
• Preliminares: Utilizar preguntas libres de contexto.
• Brainstorming: Seleccionar un grupo variado de participantes. Eliminar críticas,
juicios y evaluaciones mientras los participantes sugieren ideas. Producir muchas
ideas. Recogerlas todas por escrito. Otro día, en otra sesión, se evalúan las ideas.
• Entrevistas: Es el método “tradicional”, pero debe usarse en complemento con
otras técnicas, y no debe ser el primer paso de la recolección. Es fundamental:
Entrevistar a la(s) persona(s) adecuadas. Preparar las preguntas con antelación.
Utilizar diagramas, modelos, etc.
• Observación y análisis de tareas: Un observador estudia a los futuros usuarios en
su entorno de trabajo. A veces se utiliza el video. Anota todo aquello que es
susceptible de mejora. Posteriormente, genera una serie de requisitos tentativos.
• Casos de uso / Escenarios: Requisitos en contexto de uso.
• Prototipado: Útiles cuando la incertidumbre es total acerca del futuro sistema. Hay
dos tipos principales: evolutivo y “de usar y desechar” [31].
Análisis de requisitos
Se contemplan los principios y métodos de modelado de los requisitos del
software siguiendo el paradigma de la orientación a objeto. Consiste en detectar y
resolver conflictos entre requisitos. Se precisan los límites del sistema y la
interacción con su entorno. Se trasladan los requisitos de usuario a requisitos del
software (implementables).
12
En el análisis de requisitos se realizan tres tareas fundamentales:
Clasificación:
• En funcionales vs. no funcionales (Capacidades vs. Restricciones).
• Por prioridades.
• Por coste de implementación.
• Por niveles (alto nivel, bajo nivel).
• Según su volatilidad/estabilidad.
• Si son requisitos sobre el proceso o sobre el producto.
Modelización Conceptual:
• Ciertos aspectos de los requisitos se expresan mediante modelos de datos, de
control, de estados, de interacción, de objetos, etc.
• La meta es entender mejor el problema, más que iniciar el diseño de la solución.
• El tipo de modelo elegido depende de la naturaleza del problema, la experiencia
del modelizador, y de la disponibilidad de herramientas. Por decreto el cliente
impone una notación.
Negociación:
• En todo proceso de IR intervienen distintos individuos con distintos y, a veces,
enfrentados intereses.
• Estos conflictos entre requisitos se descubren durante el análisis. El conflicto no es
rechazable, pues los conflictos son fuente de nuevos requisitos.
• Los conflictos nunca se deben resolver “por decreto”, sino mediante un proceso de
(re)negociación [31].
13
Especificación o documentos de requisitos
Esta parte está relacionada con la representación de los requisitos como
resultado de la recopilación y análisis de los mismos. Incluye la aplicación de los
métodos de especificación incluyendo lenguaje natural y lenguajes de modelado. Es
el modo habitual de guardar y comunicar requisitos. Es buena práctica utilizar, al
menos, dos documentos, a distinto nivel de detalle:
DRU: Documento de Requisitos de Usuario (en inglés, URD). El DRU se escribe
desde el punto de vista del usuario/cliente/interesado. Normalmente los requisitos de
usuario, contenidos en la DRU, no poseen demasiado nivel de detalle. Se incluye la
descripción del problema actual (razones por las que el sistema de trabajo actual es
insatisfactorio) y las metas que se espera lograr con la construcción del nuevo
sistema.
ERS: Especificación de Requisitos Software (en inglés, SRS). La ERS desarrolla
mucho más los contenidos de la DRU. Los requisitos del software contenidos en la
ERS son, por tanto, más detallados. Contiene la respuesta a la pregunta “¿Qué
características debe poseer un sistema que nos permita alcanzar los objetivos, y evitar
los problemas, expuestos en la DRU?”.Un documento es cualquier medio electrónico
de almacenamiento y distribución (procesador de textos, base de datos, herramienta
de gestión de requisitos) [31].
Validación de Requisitos
14
El objetivo de la validación de requisitos es descubrir problemas en el
documento de requisitos antes de comprometer recursos a su implementación. Como
resultado de esta validación se produce una línea-base (baseline).
El
documento
debe
revisarse
para
descubrir
omisiones,
conflictos,
ambigüedades, y comprobar la calidad del documento y su grado de adhesión a
estándares.
Línea Base: En el contexto de la Ingeniería de Requisitos, una línea base es un
conjunto de requisitos que han sido formalmente aceptados por todas las personas
implicadas en el proyecto. Una vez que se establece una línea base, futuros cambios a
tales requisitos sólo podrán realizarse por medio de un proceso formal de gestión y
aprobación de cambios.
Revisiones (Reviews): Es la fórmula más empleada para validación. Un grupo de
personas (incluyendo usuarios) se ocupan de revisar el documento de requisitos.
Consta de tres fases:
1. Búsqueda de problemas.
2. Reunión.
3. Acuerdos.
Como guía para identificar problemas habituales, se pueden utilizar listas de
comprobación (“checklists”). Existen checklists adaptadas a distintos tipos de
sistemas. Una checklist debería girar alrededor de los 24 atributos de calidad que
debería poseer una ERS.
Otros métodos de validación:
15
Prototipado: Permite descubrir con rapidez si el usuario se encuentra satisfecho, o
no, con los requisitos (Uso de escenarios/casos de uso).
Validación de modelos: Cuando los requisitos se expresan por medio de modelos (de
objetos, DFDs, etc.).
Validación de su “testabilidad”: El equipo de pruebas debe revisar los requisitos.
Gestión de Requisitos
Consiste, básicamente, en gestionar los cambios a los requisitos. Asegura la
consistencia ente los requisitos y el sistema construido (o en construcción). Consume
grandes cantidades de tiempo y esfuerzo. Abarca todo el ciclo de vida del producto.
La Gestión de Requisitos es necesaria porque los requisitos son volátiles, el entorno
físico y el entorno organizacional cambian, y la propia existencia del sistema va a
generar nuevos requisitos por parte de los usuarios.
Qué implica la Gestión de Requisitos:
• Definir procedimientos de cambios: definen los pasos y los análisis que se
realizarán antes de aceptar los cambios propuestos.
• Cambiar los atributos de los requisitos afectados.
• Mantener la trazabilidad: hacia atrás, hacia delante y entre requisitos.
• Control de versiones del documento de requisitos.
• Herramientas de Gestión de Requisitos: facilitan las tareas relacionadas con la
escritura, trazabilidad y gestión de cambios.
• Organizan los requisitos en bases de datos.
• Gestión (incremental) de lineas-base.
16
• Todas permiten añadir atributos a los requisitos.
• Creación de líneas base: Una línea base (baseline) es un conjunto de requisitos
que, mediante acuerdo entre las partes implicadas, se ha decidido no modificar.
Son aquellos requisitos más importantes que el desarrollador se compromete a
implementar. A lo largo de un proceso de requisitos pueden crearse
(incrementalmente) varias líneas base. Las herramientas de gestión de requisitos
permiten gestionar fácilmente las líneas base. Por ejemplo, los requisitos que
forman parte de una línea base no podrán ser modificados, salvo por usuarios
privilegiados [31].
II.3.
Desarrollo de Software Orientado a Objetos (POO)
El Desarrollo de Software Orientado a Objetos (DSOO) es la tecnología que
permite colocar todos los atributos y métodos de un “objeto” en una estructura
independiente llamada clase. Un objeto contiene toda la información, (los
denominados atributos) que permite definirlo e identificarlo frente a otros objetos
pertenecientes a otras clases (e incluso entre objetos de una misma clase, al poder
tener valores bien diferenciados en sus atributos). A su vez, dispone de mecanismos
de interacción (los llamados métodos) que favorecen la comunicación entre objetos
(de una misma clase o de distintas), y en consecuencia, el cambio de estado en los
propios objetos. Esta característica lleva a tratarlos como unidades indivisibles, en las
que no se separan (ni deben separarse) información (datos) y procesamiento
(métodos) [7].
La idea de las clases es tener un punto de referencia y describir las similitudes o
diferencias que un objeto específico posee con respecto a los miembros de su propia
clase. Una clase define el conjunto de atributos y comportamientos compartidos por
cada objeto de la clase. Los programadores deben definir las diversas clases en el
17
programa que escriben y crear los objetos a partir de la clase establecida, esto se
conoce con el término de “instanciar” [7].
II.4.
Programación Orientada a Objetos (POO)
La Programación Orientada a Objetos (POO u OOP según siglas en inglés) es
un paradigma de programación que define los programas en términos de "clases de
objetos", objetos que son entidades que combinan estado (es decir, datos),
comportamiento (esto es, procedimientos o métodos) e identidad (propiedad del
objeto que lo diferencia del resto). La programación orientada a objetos expresa un
programa como un conjunto de estos objetos, que colaboran entre ellos para realizar
tareas. Esto permite hacer los programas y módulos más fáciles de escribir, mantener
y reutilizar [32].
Esto difiere de los lenguajes imperativos tradicionales, en los que los datos y
los procedimientos están separados y sin relación, ya que lo único que se busca es el
procesamiento de unos datos de entrada para obtener otros de salida. La
programación estructurada anima al programador a pensar sobre todo en términos de
procedimientos o funciones, y en segundo lugar en las estructuras de datos que esos
procedimientos manejan. Los programadores de lenguajes imperativos escriben
funciones y después les pasan datos. Los programadores que emplean lenguajes
orientados a objetos definen objetos con datos y métodos y después envían mensajes
a los objetos diciendo qué realicen esos métodos en sí mismos [32].
Los conceptos de la programación orientada a objetos tienen origen en Simula
67, un lenguaje diseñado para hacer simulaciones, creado por Ole-Johan Dahl y
Kristen Nygaard del Centro de Cómputo Noruego en Oslo, quienes trabajaban en
18
simulaciones de naves, y fueron confundidos por la explosión combinatoria de cómo
las diversas cualidades de diversas naves podían afectar unas a las otras. La idea
ocurrió para agrupar los diversos tipos de naves en diversas clases de objetos, siendo
responsable cada clase de objetos de definir sus propios datos y comportamiento.
Fueron refinados más tarde en Smalltalk, que fue desarrollado en Simula en Xerox
PARC (y cuya primera versión fue escrita sobre Basic) pero diseñado para ser un
sistema completamente dinámico en el cual los objetos se podrían crear y modificar
"en marcha" en lugar de tener un sistema basado en programas estáticos [32].
La programación orientada a objetos tomó posición como la técnica de
programación dominante a mediados de los años ochenta, en gran parte debido a la
influencia de C++, una extensión del lenguaje de programación C. Su dominación fue
consolidada gracias al auge de las interfaces gráficas de usuario, para las cuales la
programación orientada a objetos está particularmente bien adaptada. En este caso, se
habla también de programación orientada a eventos [32].
Las características de orientación a objetos fueron agregadas a muchos
lenguajes existentes durante ese tiempo, incluyendo Ada, BASIC, Lips, Pascal, y
otros. La adición de estas características a los lenguajes que no fueron diseñados
inicialmente para ellas condujo a menudo a problemas de compatibilidad y a la
capacidad de mantenimiento del código. Los lenguajes orientados a objetos "puros",
por otra parte, carecían de las características de las cuales muchos programadores
habían venido a depender. Para saltar este obstáculo, se hicieron muchas tentativas
para crear nuevos lenguajes basados en métodos orientados a objetos, pero
permitiendo algunas características imperativas de maneras "seguras". El Eiffel de
Bertrand Meyer fue un temprano y moderadamente acertado lenguaje con esos
objetivos pero ahora ha sido esencialmente reemplazado por Java, en gran parte
19
debido a la aparición de Internet, y a la implementación de la máquina virtual de Java
en la mayoría de navegadores [32].
Características de la POO
Abstracción: cada objeto en el sistema sirve como modelo de un "agente" abstracto
que puede realizar trabajo, informar y cambiar su estado, y "comunicarse" con otros
objetos en el sistema sin revelar cómo se implementan estas características. Los
procesos, las funciones o los métodos pueden también ser abstraídos y cuando lo
están, una variedad de técnicas son requeridas para ampliar una abstracción.
Encapsulamiento: cada objeto está aislado del exterior, es un módulo natural, y cada
tipo de objeto expone una interfaz a otros objetos que especifica cómo pueden
interactuar con los objetos de la clase. El aislamiento protege a las propiedades de un
objeto contra su modificación por quien no tenga derecho a acceder a ellas, solamente
los propios métodos internos del objeto pueden acceder a su estado. Esto asegura que
otros objetos no pueden cambiar el estado interno de un objeto de maneras
inesperadas, eliminando efectos secundarios e interacciones inesperadas.
Polimorfismo: comportamientos diferentes, asociados a objetos distintos, pueden
compartir el mismo nombre, al llamarlos por ese nombre se utilizará el
comportamiento correspondiente al objeto que se esté usando. O dicho de otro modo,
las referencias y las colecciones de objetos pueden contener objetos de diferentes
tipos, y la invocación de un comportamiento en una referencia producirá el
comportamiento correcto para el tipo real del objeto referenciado.
20
Herencia: las clases no están aisladas, sino que se relacionan entre sí, formando una
jerarquía de clasificación. Los objetos heredan las propiedades y el comportamiento
de todas las clases a las que pertenecen. La herencia organiza y facilita el
polimorfismo y el encapsulamiento permitiendo a los objetos ser definidos y creados
como tipos especializados de objetos preexistentes. Estos pueden compartir (y
extender) su comportamiento sin tener que reimplementar su comportamiento. Esto
suele hacerse habitualmente agrupando los objetos en clases y estas en árboles que
reflejan un comportamiento común [32].
II.5.
Desarrollo de Software Orientado a Aspectos (DSOA)
El Desarrollo de Software Orientado a Aspectos (DSOA) o ASOD por sus
siglas en inglés, es un nuevo paradigma que cada día despierta más interés y adquiere
más relevancia. Muchos son los eventos sobre DSOA que se han presentado
internacionalmente dentro de la comunidad de Ingeniería de Software, desde el año
1996 cuando se acuñó el término por primera vez, pasando por el primer evento de
DSOA (Workshop on Aspect Oriented Programming ECOOP 1997) hasta la más
reciente edición de Las Jornadas de Ingeniería del Software y Bases de Datos que se
realizan todos los años [20] [33].
II.5.1 Objetivo principal de DSOA
El objetivo principal de DSOA es promocionar la separación de incumbencias
(Separtion of Concern) y llevar a las etapas del ciclo de vida de desarrollo del
software los avances de la POA para tratar su modularización. DSOA aparece para
resolver determinados problemas que se encuentran en el software construido
mediante técnicas convencionales y que están relacionados con la facilidad de
21
reutilización, facilidad de mantenimiento, rapidez en el desarrollo, y en definitiva,
una serie de parámetros que inciden sobre su calidad [21].
II.5.2 Breve reseña histórica
El DSOA es una nueva disciplina que se origina en el año 2002 a partir de los
avances de la POA. El concepto de POA, fue introducido por Gregor Kiczales y su
grupo; sin embargo, antes de que surgiera este concepto el Grupo Demeter, había
considerado y aplicado ideas similares [12] [18] [21].
Los trabajos del Grupo Demeter, estaban principalmente enfocados en la
programación adaptativa (PA), la cual puede verse como una instancia temprana de la
POA. El término programación adaptativa se introduce en 1991. La PA constituye un
gran avance dentro de la tecnología de software, basada en el uso de autómatas finitos
y una teoría formal de lenguaje para expresar concisamente y procesar eficientemente
conjuntos de caminos en un grafo arquitectónico, como por ejemplo los diagramas de
clase en el Lenguaje de Modelado Unificado (UML) [12] [18] [21].
Para 1995 dos miembros del grupo Demeter Cristina Lopes y Walter Huersch,
presentaron un reporte técnico sobre la separación de conceptos, incluyendo varias
técnicas como filtros composicionales y PA para tratar con los conceptos
(incumbencias) que se entrecruzan. Este reporte identificó el tema general de
separación de incumbencias y su implementación y se propuso como uno de los
problemas a resolver en el diseño y desarrollo de software [18].
No fue sino hasta 1995 cuando se publicó la primera definición del concepto
de aspecto, realizada también por el grupo Demeter, y se describía de la siguiente
22
forma: “Un aspecto es una unidad que se define en términos de información parcial
de otras unidades” [18].
Cristina Lopes y Karl Lieberherr empezaron a trabajar con Gregor Kickzales y
su grupo. A Lopes y Kickzales no les gustó el nombre “Programación Adaptativa” e
introdujeron un mejor término “Programación Orientada a Aspectos” con su propia
definición y terminología. En la literatura se lo considera a Gregor Kickzales como el
creador de este nuevo paradigma [18] [21].
En resumen:
•
El Grupo Demeter introduce en 1991 la Programación Adaptativa,
instancia temprana de la programación orientada a aspectos.
•
En 1996 Gregor Kiczales divulgó por primera vez los términos
“Aspecto” y “Programación Orientada a Aspectos”.
•
En 1997 se lleva a cabo el primer evento relacionado con el nuevo
enfoque de la POA: Workshop on Aspect-Oriented Programming
ECOOP 1997.
•
Entre 1997 y 2001 la POA adquiere madurez en los entornos de
investigación.
•
En 2002 la POA da lugar al DSOA.
•
A partir del 2003 la DSOA despierta cada día mayor interés y más
relevancia en los ámbitos de investigación y desarrollo [21].
II.5.3 La separación de incumbencias
23
El principio de separación de incumbencias fue identificado en la década de
1970, plantea que un problema dado involucra varias incumbencias que deben ser
identificadas y separadas. Esta definición en terminología inglesa (separation of
concerns), aparece frecuentemente asociada a traducciones tales como: Separación
de competencias, separación de propiedades, separación de preocupaciones,
separación de áreas de interés, entre otros. En el desarrollo de esta investigación a fin
de unificar términos todos estos son tratados como separación de incumbencias [26].
Las incumbencias (concerns) son los diferentes temas o asuntos de los que es
necesario ocuparse para resolver un problema de desarrollo de software. Una de ellas
es la función específica que debe realizar la aplicación, pero también surgen otras
como por ejemplo distribución, persistencia, replicación, sincronización. Separando
las incumbencias, se disminuye la complejidad a la hora de tratarlas y se puede
cumplir
con
requisitos
relacionados
con
la
calidad
como
adaptabilidad,
mantenibilidad, extensibilidad y reusabilidad. La separación de incumbencias es
simplemente un método para descomponer software en sus módulos, cada uno de los
cuales tratan y encapsula un área particular de interés, llamada incumbencia.
Ejemplo de incumbencias son funciones, clases o tipos de datos, características (tales
como persistencia, impresión, o control de concurrencia) [26].
En muchos casos, es difícil expresar de una forma modular incumbencias
importantes de una aplicación de software. El mayor problema radica en que el
código que las trata se encuentra a menudo diseminado sobre muchas partes de la
aplicación, con el inconveniente de estar “disperso” y “enmarañado”, como se
muestra en la figura 2.1.
24
Buena modularización: una propiedad o funcionabilidad aparece localizad en un módulo
Mala modularización: una propiedad o funcionabilidad aparece dispersa y enmarañada
Figura 2.1
Disperso: (Scattered): La especificación relativa a una propiedad o
funcionalidad no se encuentra localizada en un módulo sino que se encuentra dispersa
en una serie de ellos.
Enmarañado (Tangled): Los diferentes módulos contienen descripciones
mezcladas relativas a varias propiedades o funcionalidades.
Estas responsabilidades, que aparecen diseminadas en el código atravesando
partes del sistema no relacionadas en el modelo, se denominan incumbencias
transversales (crosscutting concerns) [26].
25
II.5.4 Ventajas de la separación de incumbencias
Las ventajas del uso de tecnologías de separación de incumbencias en el
desarrollo de aplicaciones software se resumen básicamente en dar solución a los
problemas planteados por el entrecruce de las mismas. De una forma más detallada,
las ventajas son:
− Representación explícita de las diferentes incumbencias que se engloban
dentro de una aplicación software. Proporciona un alto grado de modularidad
al manejar las diferentes incumbencias como entidades de primera clase.
− Alto grado de reutilización de la aplicación, por un lado, y de las
incumbencias ajenas a la funcionalidad base, por otro. Al mejorar la
modularidad, proporcionando mecanismos de separación y de interacción, se
consigue código más independiente y reutilizable.
− Facilita la comprensión de la funcionalidad base de la aplicación, al eliminar
la mezcla de código.
− Facilita los procesos de mantenimiento y evolución.
II.5.5 Tiranía de la Descomposición dominante
Con las técnicas de modelado convencionales no puede evitarse la mezcla de
aspectos debido a la tiranía de la descomposición dominante. Cuando se descompone
26
y se modulariza un problema, se hace atendiendo a unos criterios donde predominan
una serie de propiedades; pero que, lamentablemente penalizan a otras.
Cuando sucede la mezcla de aspectos, como se muestra en la figura 2.3, la
separación de incumbencias no es siempre una tarea fácil. Cuando los sistemas de
software alcanzan una cierta complejidad, las construcciones de modularización
proporcionadas por los lenguajes actuales se muestran insuficientes.
Usualmente es necesario tener de manera simultánea diferentes dimensiones
de abstracción de conceptos; que además, es posible que se solapen e interactúen. Se
necesita la modularización respecto a diferentes dimensiones, ya sea, por clases,
aspectos, roles o cualquier otro criterio [21].
Mezcla de aspectos
Figura 2.3
Las técnicas actuales de ingeniería del software proporcionan generalmente un
mecanismo de descomposición dominante que no es adecuado para capturar y
representar todas las incumbencias (propósitos) que se pueden encontrar en una
aplicación software. Ejemplos de descomposiciones tiránicas son las clases en el
paradigma orientado a objetos y las funciones en la programación funcional. El
problema de las incumbencias transversales es que son consecuencia de la
27
descomposición del software en módulos basados sólo en la dimensión dominante
por la cual se haya realizado la modularización.
La separación de aspectos sugiere la posibilidad de trabajar en el diseño e
implementación de un sistema con unidades naturales de incumbencias en vez de
hacerlo con unidades impuestas por las herramientas o lenguajes de desarrollo. En
definitiva, la idea es adaptar la modularidad de un sistema para que refleje la manera
en la que un ingeniero razona sobre un problema en vez de adaptar la manera de
razonar al modo que imponen las herramientas y los lenguajes [21].
II.5.6 Incumbencias Transversales
Las incumbencias transversales (crosscutting concerns) afectan a distintas
partes del sistema, son transversales en el sentido, que se cruzan a la estructura
impuesta por la descomposición principal que se haya hecho del sistema de software;
es decir, no caben en ningún modulo [21] [27].
En la POO esto ocurre fácilmente, un ejemplo clásico se podrá ver en la figura
2.2, donde dos clases diferentes punto (Point) y línea (Line) presentan los métodos
(setX, setY, setP1, setP2) encapsulados en el crosscutting concern de notificación de
movimiento de una figura (Display Updating) que podría ser representado como un
aspecto y evitar la redundancia.
28
Figura 2.2
El problema de las incumbencias transversales, sucede cuando estas aparecen
en el sistema y no pueden ser programadas de forma independiente; en ese caso, la
única solución suele ser escribir código repetido que resuelva esa incumbencia para
cada subsistema (clase). Para solucionar estos problemas nace la POA, que
proporciona los mecanismos suficientes para tratar en forma independiente las
incumbencias y convertirlas en aspectos de un sistema [21].
II.5.7 Alternativas de Solución
Contra la tiranía de la descomposición dominante, se debe permitir múltiples
dimensiones de descomposición basadas en SEPARACIÓN DE ASPECTOS, ver
figura 2.4.
Para la implementación de estas funcionalidades (aspectos), idealmente
ortogonales a la funcionalidad básica y para conseguir una adecuada modularización
de un sistema de software, se han desarrollado diversas alternativas tecnológicas que
posibilitan una mejor separación de los conceptos o que las conforman. Gracias a
ellas se pueden capturar las diferentes incumbencias (concern) que componen una
aplicación en entidades bien definidas, de manera apropiada en cada uno de los casos,
eliminando las dependencias inherentes entre cada uno de los módulos.
Estas
tecnologías se agrupan hoy en día de manera general en el paradigma del DSOA.
29
Figura 2.4
II.6.
Programación Orientada a Aspectos (POA)
La Programación Orientada a Aspectos (POA) es un paradigma de
programación que surgió tratando de solucionar dos problemas detectados durante la
construcción de software: el primero, el enmarañamiento del código y el segundo, el
hecho de que determinados objetos no pudiesen ser manejados con la programación
orientada a objetos, distribuyéndose en diferentes clases (dispersión). La POA es un
desarrollo que sigue al paradigma de desarrollo de orientación a objetos [8].
La POA ha sido propuesta como una técnica para mejorar la separación de
concerns (áreas de interés o propiedades) en el software; se encuentra construida
sobre tecnologías previas como la programación orientada a objetos (POO) y la
programación basada en procedimientos; por lo tanto puede decirse que la POA no
rompe con las técnicas de programación orientadas a objetos, por el contrario las
complementa y extiende. De manera general se ha definido la POA como la
tecnología que proporciona la separación de crosscutting concerns introduciendo una
nueva unidad de modularización denominada ASPECTO [8].
La idea principal de esta nueva técnica es modularizar todos los concerns de
importancia en los sistemas complejos, los cuales no pueden ser manejados con los
30
lenguajes orientados a objetos y sus mecanismos de modularidad jerárquica. Se dice
que la POA hace por los crosscutting concerns lo que la POO ha hecho por la
encapsulación de objetos y la herencia; es decir proporciona mecanismos al lenguaje
para capturar explícitamente la estructura transversal, haciendo posible programar
estos crosscutting concerns en una forma modular; obteniendo un código más
sencillo, más fácil de desarrollar y mantener. POA es DSOA en la etapa de
implementación. Son lenguajes y plataformas de programación que dan soporte a la
separación de aspectos [8].
II.6.1
Terminología Básica
Son diversas las definiciones que se utilizan en el enfoque orientado a aspectos,
muchos de los autores utilizan los términos libremente; sin embargo a continuación
se presentan los principales conceptos comunes que han sido definidos dentro de la
comunidad de investigadores. Para algunos de estos términos se prefiere conservar el
nombre en inglés con el fin de evitar ambigüedades en sus descripciones.
Concern: Un concern, figura 2.5, se define como una propiedad o punto de
interés de un sistema. La IEEE define los concerns para un sistema como aquellos
intereses que pertenecen al desarrollo del sistema y su operación, o demás aspectos
que son críticos; o por el contrario, importantes para uno o varios stakeholders. Los
concerns
incluyen
consideraciones
del
sistema
tales
como
performance,
confiabilidad, seguridad, distribución, persistencia, entre otros. Se define un concern
como un requisito de un sistema o consideración que debe ser direccionada con el fin
de satisfacer una meta del sistema; puede ser clasificado en dos categorías: core
concerns capturan la funcionalidad central de un módulo y los crosscutting concern
capturan a nivel del sistema los requisitos secundarios que atraviesan múltiples
módulos [34].
31
Figura 2.5
Crosscutting Concerns: Los crosscutting concerns, figura 2.6, (conocidos en
la comunidad en español como incumbencias entrecruzadas o conceptos
transversales), son aquellas propiedades que se reparten a lo largo de todo el código
de una aplicación, son conceptos que no pueden encapsularse dentro de una unidad
funcional, debido a que atraviesan todo el sistema [33].
2.6 of Concerns (SOC) o separación de
Separación de “Concerns”: LaFigura
Separation
conceptos es un término utilizado desde hace muchos años; fue primero introducido
por Dijkstra, como un principio para encapsular características en entidades separadas
con la finalidad de ubicar en un lugar particular sus cambios y tratarlas una por una
en el tiempo (ejemplo: UML utiliza diferentes modelos para tratar las diversas
32
propiedades del dominio de un problema por separado). Sin embargo, Parnas fue
acreditado por el concepto de SOC cuando propuso la programación modular en
como la mejor manera de estructurar el código de un programa, para hacer software
reutilizable y más simple de evolucionar. Según Parnas, la mejor manera de alcanzar
la SOC es través de la modularización, un proceso de crear módulos que oculten sus
decisiones entre sí [35].
En forma general, la SOC ha sido definida como la habilidad de identificar,
encapsular y manipular partes del software (concerns) que son relevantes para un
propósito particular; la SOC permite reducir la complejidad del software y mejorar la
entendibilidad y trazabilidad a lo largo de un proceso de desarrollo, minimizando el
impacto del cambio que promueve la evolución [35].
Aspecto: Un Aspecto se define como una unidad modular diseñada para
implementar un concern, pueden contener en su definición código y las
correspondientes instrucciones de donde, cuando y como invocarlo. Los Aspectos son
unidades modulares de implementaciones comunes, definidos por medio de
declaraciones de tipo aspecto, las cuales tienen una forma similar a las declaraciones
de las clases en el enfoque orientado a objetos.
En [8] Kiczales define un aspecto de programa o código como la unidad
modular que aparece en otras unidades modulares del programa, similar a una clase
pero con un nivel de abstracción mayor; Kiczales también define un Aspecto como la
estructura que encapsula un crosscutting concern.
33
Figura 2.7
En la figura 2.7 se visualiza la representación del Aspecto (Display Updating)
el cual encapsula el crosscutting concern de notificación de movimiento de una
figura, implementado por los métodos (setX, setY, setP1, setP2). Se dice que este
concern es un crosscutting concern debido a que entrecruza las clases Point y Line
[8].
Join Points: Los Join Points, figura 2.8, o puntos de unión son lugares bien
definidos donde un comportamiento adicional es agregado en la estructura de
ejecución o flujo de un programa. Los Joint Points representan el concepto central de
la Programación Orientada a Aspectos y el de su principal lenguaje de
implementación AspectJ, se definen como puntos en la ejecución dinámica de un
programa interceptados por los aspectos, y en los cuales secciones adicionales de
código denominadas advice pueden ser ejecutadas.
De manera elemental, un joint point es cualquier punto de ejecución
identificable en un sistema, la llamada a un método es un joint point y la ejecución de
un método también lo es; una asignación a una variable, la construcción de un objeto,
una comparación, un manejador de excepciones entre otros, son ejemplos que
permiten identificar tal concepto. Sin embargo; no todos los joint points en un
sistema están disponibles para ser usados, los exposed joint points en el sistema
34
(puntos de unión expuestos) son los únicos lugares posibles en el código donde se
puede ampliar o alterar la ejecución del programa principal [8] [35].
Pointcut: Un pointcut o punto de corte es un conjunto de joint points; también
se definen como una estructura diseñada para identificar y seleccionar los join points
dentro de un programa en AspectJ. Los joint points seleccionados en los pointcuts son
los denominados exponed joint points. Un pointcut es un término particular utilizado
en la programación con AspectJ [8] [35].
Figura 2.8
Advice: Un advice es el comportamiento que ha de ser ejecutado en un joint
point
que ha sido seleccionado. Un advice ayuda a definir “qué hacer”, es un
mecanismo muy similar a un método, usado para declarar el código que debe
ejecutarse en cada joint point que es capturado por el pointcut. Existen tres tipos de
advice: before advice (se ejecuta previo al joint point), after advice (se ejecuta
siguiendo al joint point) y around advice (encierra la ejecución del joint point); este
35
último tiene la habilidad de desviar la ejecución, continuar la ejecución normal o
causar la ejecución con un contexto alterado.
Los pointcuts y advice forman juntos las reglas de entrelazado dinámico
(dynamic crosscutting: tejido de nuevo comportamiento dentro de la ejecución de un
programa) propias de la programación orientada a aspectos; mientras los pointcuts
identifican los joint points requeridos, el advice completa el cuadro determinando las
acciones que ocurrirán en los joint points [8] [35].
II.6.2
Fundamentos de la Programación Orientada a Aspectos
Los tres principales requerimientos de la POA son:
- Un lenguaje para definir la funcionalidad básica, conocido como lenguaje
base o componente. Podría ser un lenguaje imperativo, o un lenguaje no
imperativo (C++, Java, Lisp, ML).
- Uno o varios lenguajes de aspectos, para especificar el comportamiento de
los aspectos. (COOL, para sincronización, RIDL, para distribución, AspectJ,
de propósito general.)
- Un tejedor de aspectos (Weaver), que se encargará de combinar los
lenguajes. Tal proceso se puede retrasar para hacerse en tiempo de ejecución o
en tiempo de compilación.
En la siguiente Figura 2.9, se aprecia la forma en que se trabaja con las
aplicaciones tradicionales y cómo se opera en una aplicación orientada a aspectos.
36
Figura 2.9
En las aplicaciones tradicionales, era suficiente con un compilador o intérprete
que tradujera el programa escrito en un lenguaje de alto nivel a un código
directamente entendible por la máquina.
En las aplicaciones orientadas a aspectos, sin embargo, además del compilador,
hay que tener el tejedor, que nos combine el código que implementa la funcionalidad
básica, con los distintos módulos que implementan los aspectos, pudiendo estar cada
aspecto codificado con un lenguaje distinto [12].
II.6.3
Lenguajes Orientados a Aspectos
Los lenguajes Orientados a Aspectos (LOA) son las herramientas que permiten
soportar el paradigma de la POA, estos lenguajes proporcionan un conjunto de
mecanismos y constructores para capturar aquellos elementos que se diseminan por
todo los sistemas de software. Los LOA permiten separar la definición de la
funcionalidad pura, de la definición de los diferentes aspectos; definen una nueva
unidad de programación de software denominada Aspecto para encapsular las
funcionalidades que cruzan todo el código, deben soportar la separación de concerns
37
como la sincronización, la distribución, el manejo de errores, la optimización de
memoria, la seguridad, la persistencia, etc.
Las implementaciones de los LOA ejecutan dos pasos lógicos: combinan los
concerns individuales utilizando reglas de tejido (weaving rules) y entonces convierte
la información resultante en código ejecutable. Este proceso de combinar los
concerns individuales de acuerdo a esas reglas de tejido es llamado weaving o tejido.
Actualmente se distinguen dos enfoques diferentes en el diseño de lenguajes de
aspectos: lenguajes de aspectos de dominio específico y lenguajes de aspecto de
propósito general.
II.6.3.1
Lenguajes de Aspectos de Dominio Específico
Los LOA de Dominio Específico soportan uno o más de los concerns
distribución, coordinación, manejo de errores, optimización de memoria, seguridad,
persistencia. No pueden soportar otros concerns distintos para los que fueron
especificados, poseen un nivel de abstracción mayor al del lenguaje base. Estos
lenguajes se caracterizan por imponer restricciones en la utilización del lenguaje
base, para garantizar que los conceptos del dominio sean programados en el lenguaje
diseñado para tal fin, evitándose así interferencias entre ambos. Entre algunos de los
lenguajes de aspectos de dominio específico más utilizados se encuentran COOL y
RIDL, el primero trata el concern de sincronización y el segundo la distribución.
COOL (COOrdination Language) es el lenguaje de aspectos de propósito
específico creado por XEROX; permite la sincronización de hilos (threads)
concurrentes, utiliza como lenguaje base una versión restringida de Java. Además de
tratar con los estados de sincronización, proporciona medios para tratar la exclusión
38
de hilos, suspensiones y notificaciones. Un programa COOL consiste de un conjunto
de
módulos
coordinadores.
Los
módulos
coordinadores,
o
directamente
coordinadores, se asocian con las clases a través del nombre. Un mismo coordinador
puede coordinar a más de una clase. La unidad mínima de sincronización es el
método [36].
RIDL (Remote Interaction and Data transfer Language) trata la programación
de interacciones entre componentes remotos, en particular la invocación remota y
transferencia de datos. Un programa RIDL consiste de un conjunto de módulos de
portales. Los módulos de portales o directamente portales se asocian con las clases
por el nombre. Un portal es el encargado de manejar la interacción remota y la
transferencia de datos de la clase asociada a él, y puede asociarse como máximo a una
clase. La unidad mínima de interacción remota es el método [36].
Entre otro de los lenguajes de aspectos de dominio específico puede
mencionarse a Malaj (usado en la programación distribuida) trata los concerns de
distribución y relocalización [36].
II.6.3.2
Lenguajes de Aspectos de Propósito General
Los Lenguajes orientados a Aspectos de Propósito General; están diseñados
para ser utilizados con cualquier tipo de concern. No imponen restricciones en el
lenguaje base utilizado, normalmente tienen el mismo nivel de abstracción que el
lenguaje base y el mismo conjunto de instrucciones. El lenguaje de aspecto de
propósito general más extendido en la actualidad es AspectJ. AspectJ utiliza como
lenguaje base a Java, las instrucciones de los aspectos son escritas también en Java.
39
AspectJ, es una extensión de propósito general para el lenguaje de
programación Java, cuya primera versión fue lanzada en 1998 por el equipo de
Gregor Kiczales; permite extender a Java con una nueva clases de módulos
denominados aspectos, los cuales mejoran la separación de concerns. AspectJ soporta
dos tipos de implementaciones de entrelazado (crosscutting). La primera, entrelazado
dinámico o dynamic crosscutting hace posible definir implementaciones adicionales
para correr ciertos puntos bien definidos en la ejecución de un programa; la segunda,
entrelazado estático o static crosscutting hace posible la modificación de la estructura
estática de los tipos (clases, interfases y otros aspectos) y su comportamiento en
tiempo de compilación, definiendo nuevas operaciones o tipos existentes [33].
Entre otros lenguajes de propósito general pueden mencionarse a JPAL
(Junction Point Aspect Language) lenguaje basado en Joint Points, AspectC
(subconjunto de AspectJ que extiende a C), AspectS (subconjunto de AspectJ que
extiende el ambiente Squeak/Smalltalk), AspectC++ (extiende el lenguaje C++ para
soportar el manejo de aspectos) y HyperJ (identifica, encapsula e integra múltiples
dimensiones de concerns) [33].
CAPÍTULO III
MARCO METODOLÓGICO
40
III.1.
Tipo de investigación
La investigación es del tipo Proyectos Factibles [13], ya que consistió en la
investigación, elaboración y desarrollo de una propuesta de un modelo operativo
viable para solucionar problemas, requerimientos o necesidades de organizaciones o
grupos sociales, y tiene su apoyo en una investigación de tipo documental porque
estuvo basada en la indagación, organización, interpretación y presentación de
información alrededor de la Programación Orientada a Aspectos proveniente de
fuentes bibliográficas y electrónicas reconocidas y de comprobada autenticidad [1].
III.2.
Nivel de la investigación
El nivel de la investigación es descriptivo-analítico, puesto que se basa en la
descripción de los conceptos de la POA, también en el análisis de la información
donde se destacan los aspectos más relevantes, por último se hizo el diseño del
modelo y desarrollo del código del caso de estudio en base a este análisis [1].
III.3. Fuentes y técnicas de recolección de información
Las fuentes de la investigación la conformaron fuentes primarias: grupos de
investigación de la Universidad de Oriente, asistencia a ponencias y jornadas
tecnológicas (Jornadas Tecnológicas PDVSA Sucre 2006 – ASOVAC Sucre 2006);
fuentes secundarias: fuentes bibliografías y electrónicas como textos, monografías,
exposiciones y trabajos de investigación a las que se hacen referencia en este trabajo.
Las técnicas de recolección de información fueron las propias de la investigación
documental: el subrayado, la ficha, la bibliografía, etc. El subrayado fue un
procedimiento muy utilizado para destacar ciertos conceptos, frases o argumentos en
41
las obras que se consultaron. Las fichas constituyeron el instrumento básico para
recoger la información de las distintas fuentes documentales, facilitando la
clasificación de los diversos datos requeridos y que sirvieron para la redacción final
de este trabajo [1][13]. También se hizo uso de las herramientas descargadas de los
sitios web reconocidos que hacen referencia al tema. Entre estos recursos se
encuentran las herramientas para trabajar con la programación de aspectos.
III.4. Metodología: Análisis y Diseño de Sistemas Orientado a Objetos
usando el Lenguaje Unificado de Modelación (UML)
Como el objetivo de este trabajo fue el de implementar requisitos no
funcionales a través de la programación orientada a aspectos en un sistema de
software, se tomó como punto de partida el análisis y diseño orientado a objetos para
la construcción del código base como se hace referencia en [7]. Los sistemas
orientados a objetos describen las entidades como objetos. Los objetos son parte de
un concepto general denominado clases (concepto importante para la POA).
La idea de las clases es tener un punto de referencia y describir las similitudes o
diferencias que un objeto específico posee con respecto a los miembros de su propia
clase. Una clase define el conjunto de atributos y comportamientos compartidos por
cada objeto de la clase. Por ejemplo, los registros de los estudiantes en la sección de
un curso almacenan información similar para cada estudiante. Se podría decir que los
estudiantes constituyen una clase, los valores podrían ser diferentes para cada
estudiante, pero el tipo de información es el mismo. Los programadores deben definir
las diversas clases en el programa que escriben y crear los objetos a partir de la clase
establecida, esto se conoce con el término de “instanciar”. Por ejemplo, un programa
podría instanciar a un estudiante llamado Pedro Pérez como un objeto de la clase
denominada Estudiante [7].
42
En este trabajo se utilizaron clases desarrolladas en el lenguaje de
programación Java y se instanciaron objetos a partir de éstas, para tratar los requisitos
funcionales como, por ejemplo, las transacciones de agregar, editar o eliminar un
registro en un sistema de software (caso de estudio).
Lo que hace a la programación orientada a objetos, y por consiguiente al
análisis y diseño orientado a objetos, diferente de la programación clásica, es la
técnica de colocar todos los atributos y métodos de un objeto en una estructura
independiente, la propia clase. Esta es una situación común en el mundo físico, por
ejemplo, un paquete con harina para pastel empacado es similar a una clase ya que
contiene los ingredientes y las instrucciones para mezclar y hornear el pastel. Un
suéter de lana es similar a una clase porque incluye una etiqueta con instrucciones del
cuidado que advierte que se debe de lavarlo a mano y ponerlo a secar extendido [7].
Igualmente todas las clases del caso de estudio que se desarrollaron en este trabajo
están formadas por atributos y métodos encapsulados en una estructura
independiente.
El lenguaje Unificado de Modelación (UML), por sus siglas en inglés, es el
estándar de la industria para modelar sistemas orientados a objetos, el conjunto de
herramientas UML incluye diagramas que permiten visualizar la construcción de un
sistema orientado a objetos. El UML es una herramienta poderosa que puede mejorar
enormemente la calidad del análisis y diseño de sistemas, y contribuir por tanto a
crear sistemas de información de alta calidad [7]. Se utilizó en este trabajo el lenguaje
Unificado de Modelación (UML) para modelar las clases que integrarán la
funcionabilidad principal del caso de estudio, así como las especificaciones de los
requisitos no funcionales vía aspectos.
43
Con el uso iterativo de UML es posible lograr una mayor comprensión en
relación con los requerimientos del sistema y los procesos que necesitan realizarse en
este último para cumplir dichos requerimientos. Al terminar el análisis y diseño, se
tuvo un conjunto preciso y detallado de especificaciones para las clases, procesos y
otros artefactos del sistema, lo cual contribuye a evitar el costo de volver a codificar a
causa de una pobre planeación inicial. Un artefacto es un término general que se
utiliza para describir cualquier pieza de información usada o producida al desarrollar
sistemas. Podría ser un diagrama, texto descriptivo, instrucciones de usuario, métodos
del código, programas o cualquier otro componente del sistema [7].
III.5.
Conceptos y diagramas de UML
Como se representa en la figura 3.1, UML consiste de cosas, relaciones y
diagramas. Los primeros componentes, o elementos principales de UML se
denominan cosas. Las cosas estructurales son más comunes, son clases, interfases,
clases de uso y muchos otros elementos que proporcionan una forma de crear
modelos. Las cosas estructurales permiten al usuario describir relaciones. Las cosas
de comportamiento describen como funcionan las cosas, las interacciones y las
máquinas de estado son ejemplos de cosas de comportamiento. Las cosas de
agrupamiento se usan para definir límites, un ejemplo de una cosa de agrupamiento es
un paquete. Por último, tenemos las cosas de anotación para que podamos agregar
notas a los programas.
Las relaciones son el pegamento que une las cosas, es útil considerar a las
relaciones de dos formas. Las relaciones estructurales se usan para enlazar las cosas
en los diagramas estructurales, incluyen dependencias, agregaciones, asociaciones y
generalizaciones. Por ejemplo, las relaciones estructurales muestran herencia. Las
relaciones de comportamiento se usan en los diagramas de comportamiento, los
44
cuatro tipos básicos de diagramas de comportamiento son: comunica, incluye,
extiende y generaliza [7].
Categoría UML
Elementos de UML
Detalles específicos de UML
Cosas
Cosas estructurales
Clases
Interfases
Colaboraciones
Casos de uso
Clases activas
Componentes
Nodos
Cosas de comportamiento
Interacciones
Máquinas de estado
Cosas de agrupamiento
Paquetes
Cosas de anotación
Notas
Relaciones estructurales
Dependencias
Agregaciones
Asociaciones
Generalizaciones
Relaciones de comportamiento
Comunica
Incluye
Extiende
Generaliza
Diagramas estructurales
Diagramas de clase
Diagramas de componentes
Diagramas de despliegue
Diagramas de comportamiento
Diagramas de casos de uso
Diagramas de secuencias
Diagramas de colaboración
Diagramas de gráfico de estado
Diagramas de actividades
Relaciones
Diagramas
Figura 3.1
Hay dos tipos principales de diagramas en UML: diagramas estructurales y
diagramas de comportamiento. Los diagramas estructurales se utilizan para describir
las relaciones entre las clases, incluyen diagramas de clases, diagramas de objetos,
diagramas de componentes y diagramas de despliegue. Por otro lado, los diagramas
45
de comportamiento se pueden usar para describir las interacciones entre las personas
(denominadas actores en UML) y la cosa que nos referimos como caso de uso, o
cómo usan los actores el sistema. Los diagramas de comportamiento incluyen
diagramas de caso de uso, diagramas de secuencia, diagramas de colaboración,
diagramas de gráficos de estado y diagramas de actividades.
Los seis diagramas de UML, que más se utilizan son:
1. Diagrama de caso de uso, que describe como se usa el sistema. Los analistas
comienzan con un diagrama de caso de uso.
2. Escenario de caso de uso (aunque técnicamente no es un diagrama), es una
descripción verbal de las excepciones para el comportamiento principal
descrito por el caso de uso principal.
3. Diagrama de actividades, ilustra el flujo general de actividades. Cada caso
de uso podría crear un diagrama de actividades.
4. Diagramas de secuencias, muestran las secuencias de actividades y las
relaciones de las clases, cada caso de uso podría generar una o más
diagramas de secuencias. Una alternativa para un diagrama de secuencias es
un diagrama de colaboración, el cual contiene la misma información en
formato diferente.
5. Diagramas de clases, muestran la clases y las relaciones, los diagramas de
secuencias se usan para determinar las clases en un diagrama gen/esp que
significa (generalización/especialización).
6. Diagramas de gráficos de estado, muestra las transiciones de estado, cada
clase podría crear un diagrama de gráfico de estado el cual es útil para
determinar los métodos de la clase [7].
46
En este trabajo se utilizó la metodología propuesta por Kendall & Kendall [7],
para el Análisis y Diseño de Sistemas usando el Lenguaje Unificado de Modelación
(UML). El desarrollo parte de estos conceptos y diagramas de UML como
herramienta principal para el análisis y diseño orientado a objetos para la
construcción del código base (requisitos funcionales), así mismo se hicieron las
especificaciones del aspecto que servirá de base para implementar los requisitos no
funcionales a través de la programación orientada a aspectos al caso de estudio.
CAPÍTULO IV
RESULTADOS
47
IV.1. Análisis de conceptos y definiciones del DSOA y de la POA
Para probar las tecnologías inherentes a la POA a nivel de implementación, fue
necesario analizar los principales conceptos que de ella se derivan, hacer uso de las
herramientas disponibles para implementar la plataforma tecnológica y comprobar
que esta tecnología en realidad funciona. Antes de desarrollar el caso de estudio,
primero se analizaron los conceptos de “crosscutting concerns”, “aspecto”, “joint
point”, “pointcut” y “advises”, los cuales son fundamentales cuando se trabaja con
aspectos a nivel de implementación. Luego de varias sesiones de trabajo y análisis de
la investigación documental, la aplicación de estos conceptos se basa en lo siguiente:
Los crosscutting concerns son aquellas propiedades (bloques de código) que se
reparten a lo largo de varias clases (POO) de una aplicación, las cuales representan un
inconveniente a la hora de la mantenibilidad del código. El problema radica en que si
se quiere quitar, colocar o modificar alguna de estas propiedades, se tiene el grave
problema de tocar mucho código y trabajar en cada una de las clases afectadas. Estas
incumbencias transversales se pueden modularizar utilizando la POA a través de
aspectos.
Los aspectos son unidades modulares que se definen de manera similar a una
clase en Java (Lenguaje base escogido en este trabajo), con sus propios atributos y
propiedades, con la diferencia que utilizan los mecanismos de joint point para indicar
en que métodos de las clases afectadas se van a insertar las propiedades
modularizadas, los pointcut que definen los cortes y están formados por un conjunto
de joint points, por último están los advises que funcionan de forma parecida a un
método y son los que contienen los bloques de código que conforman las propiedades
modularizadas del aspecto.
48
Para probar el funcionamiento de la tecnología de aspectos, fue necesario
desarrollar clases hechas en Java e implementar aspectos a través de AspectJ. Para
realizar estas pruebas se implantó en primer lugar la plataforma tecnológica para la
POA compuesta por el lenguaje base Java y el tejedor-compilador de aspectos
AspectJ. La escogencia de estas herramientas y la descripción detallada de la
implementación de la plataforma se describe en la próxima sección de este trabajo.
Una clase en Java está formada por tres elementos principales: un nombre único
que las diferencie de las otras clases, los atributos que representan alguna propiedad
de la clase y que se encuentra en todas las instancias de la clase y los métodos que
son la implementación de un servicio de la clase, muestran un comportamiento
común a todos los objetos. En resumen es una función que le indica a las instancias
de la clase que hacer. La sintaxis típica de una clase en Java es:
class NombreClase //Inicio clase
{
atributo_1; //Lista de atributos
atributo_2;
...;
public static void main(String args[]) // Función principal
{
...;
}
public void método1() //Métodos
{ ... }
public void método2()
{ ... }
public void método3()
{ ... }
} //Fin de la clase
Un aspecto en AspectJ tiene una estructura similar a una clase de Java, con sus
atributos y métodos, incorporando los elementos propios como los joint point,
pointcut y advises. La sintaxis típica de un aspecto es:
aspect NombreAspecto //Inicio aspecto
49
{
atributo_1; //Lista de atributos
atributo_2;
...;
pointcut NombrePointcut():(execution(* NombreClase1.método1(..))||
execution(* NombreClase2.método1(..))||
execution(* NombreClase3.método1(..))||
);
///*** Advise: determina el código que ha de ser ejecutado en
cada pointcut
before ():NombrePointcut()
{
...
}
after():NombrePointcut()
{
...
}
public void método1() //Métodos
{ ... }
public void método2()
{ ... }
public void método3()
{ ... }
} //Fin del aspecto
Partiendo de la estructura de estos dos elementos básicos (clases y aspecto), se
hicieron pruebas a nivel de implementación aplicándolo a un ejemplo práctico donde
se desarrolló una clase en Java que ejecutaba un proceso a través de un método que
mostraba un mensaje un número determinado de veces utilizando un bucle “For”. De
la misma forma se desarrolló un aspecto que consistió en medir el tiempo que tardaba
en ejecutarse el método de la clase. Se compiló la clase con Java y se ejecutó en
forma satisfactoria mostrando el mensaje ejecutado por el método de la clase. Luego
se hizo el tejido y compilación de la clase y aspecto con AspectJ, mostrándose los
resultados esperados con la implementación del aspecto. En resumen, la tecnología
referenciada en la bibliografía se probó de la siguiente manera:
1.- Se codificó una clase en Java para ejecutar un proceso determinado.
50
2.- Se codificó un aspecto para medir el tiempo que tardaba en ejecutarse el proceso.
3.- Se compiló la clase en Java y funcionó correctamente.
4.- Se compiló la clase y aspecto con AspectJ y la función asociada se ejecutó.
Código de la función básica
Código del aspecto
public class MiPrograma
{
long total;
public MiPrograma()
{
total = 0;
}
public static void main(String args[])
{
MiPrograma programa = new
MiPrograma();
programa.procesa();
System.out.println("");
System.out.println(" Ha finalizado
el proceso !!");
}
///*** Método "procesa"
public void procesa()
{
System.out.println("");
for(int i = 0; i < 10; i++)
{
///*** Bucle simple que muestra
"Hola Mundo" diez veces
total = total + 1;
System.out.println(" Hola Mundo
!! (" + total + ")");
}
}
}
aspect MiAspecto
{
private long tiempo = 0;
///*** Se define el pointcut
///*** que se ejecuta cuando se ejecuta
El método procesa
pointcut MiPointcut(): execution(*
MiPrograma.procesa(..));
///*** Advise: determina el código que
ha de ser ejecutado en cada pointcut
///*** antes y despues de la función
procesa
before (): MiPointcut()
{
System.out.println(" Entrada en
funcion: " + thisJoinPoint);
tiempo = System.currentTimeMillis();
System.out.println(" Tiempo inicial
en milisegundos : " + tiempo);
}
after(): MiPointcut()
{
System.out.println("");
System.out.println(" Salida de
funcion: " + thisJoinPoint);
System.out.println(" Tiempo final en
milisegundos : " +
System.currentTimeMillis() - tiempo
));
}
}
Figura 4.1
En la figura 4.1 se puede apreciar como el aspecto “MiAspecto” se implanta a
través del pointcut MiPointcut() y ejecuta la función codificada en el advises antes y
después del método “procesa” de la clase “MiPrograma”, con la finalidad de medir el
tiempo que tarda en ejecutarse.
IV.2. Implementación de la plataforma tecnológica
Para implementar el caso de estudio se escogió Java como lenguaje base y
AspectJ como lenguaje de aspectos. Java es un lenguaje de programación de alto
51
nivel de propósito general, multiplataforma y orientado a objetos. La razón de su
escogencia es que Java es independiente de la máquina y del Sistema Operativo lo
que permite ejecutar un programa hecho en Java, por ejemplo, en una computadora
con Linux o Windows, en un PDA, o en un teléfono móvil [37].
Para conseguir esto el código fuente se compila a un lenguaje que no es
específico de la plataforma, sino que es un código intermedio denominado
"bytecode". Este código no es ejecutado directamente, ya que no es comprendido
por la máquina, sino que es interpretado por un programa denominado Máquina
Virtual o más específicamente JVM (Máquina Virtual de Java). La JVM es
específica de la plataforma. De esta forma para ejecutar un programa Java sólo se
necesita la máquina virtual de la plataforma que se esté usando. Así por ejemplo,
existen máquinas virtuales para Sistemas Operativos Windows, Linux, Apple y
Solaris.
Es un lenguaje de propósito general ya que con él se pueden hacer multitud de
cosas: crear tanto programas simples de consola hasta grandes programas en entorno
gráfico, hacer los applets que lucen en las páginas web, los servlets (programas
cliente-servidor más potentes que los clásicos CGI), las JSP (Java Server Pages,
similares a las páginas PHP o ASP), los sockets (programas para redes de
ordenadores), etc [37].
Es un lenguaje orientado a objeto ya que no es un lenguaje adaptado como C++
que desciende de C, sino que es un lenguaje que desde el principio ha sido de objetos:
(casi) todo en él son objetos. Gracias a la orientación a objetos y la máquina virtual
de Java es posible descargar un programa de la red en pocos segundos ya que los
programas que se crean en Java, en general, se basan todos en las clases que
52
incorpora la máquina virtual de Java (algo así como los archivos de librerías). Es
decir, todos los archivos necesarios para que el programa funcione ya los incorpora la
máquina de destino, los posee la JVM. De esta forma los programas en Java son
robustos y potentes [37].
Con respecto al lenguaje de aspectos, AspectJ, es el más maduro y con mayor
número de características de los nombrados en el Capítulo I. AspectJ es una
extensión orientada a aspectos del lenguaje de programación Java. Permite la
aplicación de aspectos a clases Java para la solución de los problemas cruzados. Un
compilador de AspectJ produce ficheros class conformes a la especificación del
bytecode de Java, permitiendo que sean ejecutados en cualquier máquina virtual de
Java. Al utilizar Java como lenguaje base, AspectJ proporciona todos los beneficios
de Java y hace que sea sencillo que los desarrolladores Java entiendan el lenguaje
AspectJ [38].
AspectJ está formado por dos partes: la especificación del lenguaje y la
implementación del lenguaje. La parte de especificación del lenguaje define el
lenguaje en el que se escribe el código; se implementa la funcionalidad principal con
el lenguaje Java y se utilizan las extensiones proporcionadas por AspectJ para
implementar el entrelazado (weaving) de los problemas cruzados. La parte de
implementación de lenguaje proporciona herramientas para compilar, depurar e
integrar AspectJ con los entornos de desarrollo más populares [38].
En AspectJ la implementación de las reglas de entrelazado (weaving) por el
compilador es llamado concerns transversales (crosscutting). Las reglas de
entrelazado atajan hacia múltiples módulos de manera sistemática con el objetivo de
53
modularizar los problemas cruzados. AspectJ define dos tipos de crosscutting,
crosscutting estático y crosscutting dinámico [38].
crosscutting dinámico: Es el entrelazado del nuevo comportamiento durante la
ejecución de un programa. El crosscutting dinámico aumenta o incluso reemplaza el
flujo de ejecución principal del programa de una manera que afecta a los distintos
módulos, por lo tanto modifica el comportamiento del sistema. Por ejemplo, se puede
especificar que una acción determinada sea ejecutada antes de la ejecución de ciertos
métodos o manejadores de excepciones en un conjunto de clases tan sólo
especificando en un módulo separado los puntos de entrelazado (Joint Point) y la
acción a realizar cuando se alcanzan esos puntos (Advises).
crosscutting estático: Es el entrelazado de modificaciones en la estructura estática
(clases, interfases y aspectos) del sistema, como en el caso de estudio de este trabajo.
La aplicación principal del crosscutting estático es dar soporte a la implementación
del crosscutting dinámico. Por ejemplo, se pueden añadir nuevos datos y métodos a
clases e interfases para definir estados de comportamientos específicos a nivel de
clase que pueden ser usados en el crosscutting dinámico. Otro uso del crosscutting
estático es declarar advertencias y errores en tiempo de compilación a través de
múltiples módulos.
IV.2.1
Instalación del lenguaje base (Java)
54
Para desarrollar, compilar y ejecutar las clases (archivos con extensión *.java)
que conforman el código base (requisitos funcionales) de la aplicación que representa
el caso de estudio, fue necesario instalar Java como lenguaje base. En este caso se
utilizó Java JDK Edition 1.5.0.
Paso 1.- Descripción del programa
Para compilar y ejecutar con Java se utiliza habitualmente Java Development
Kit (kit de desarrollo de Java) o jdk, desarrollado por Sun Corporation. El jdk tiene
dos familias principales: Java 2 Standard Edition o J2SE, orientado a uso personal,
y Java 2 Enterprise Edition o J2EE, la edición empresarial. A su vez, cada familia
tiene diferentes versiones, identificadas por una secuencia de números x.y.z. En este
caso se utilizará Java JDK Edition 1.5.0. Java Standard Edition es una herramienta
de uso libre que se puede descargar del sitio web: http://java.sun.com/.
Paso 2.- Instalación del jdk
Para la instalación de Java JDK Edition 1.5.0, Se debió desintalar cualquier versión
de Java del equipo y limpiar las variables de entorno que tengan que ver con Java.
Para instalar el JDK, se ejecutó el programa de instalación del jdk: "jdk-1_5_0_07windows-i586-p.exe". Este archivo se encuentra en la carpeta Java JDK Edition 1.5.0
del CD que acompaña este trabajo.
Se siguieron todas las instrucciones hasta que se comenzaron a copiar todos los
archivos.
55
Cuando terminó la instalación, se pulsó el botón de finalización y se dispuso a
reiniciar el equipo (sólo si es requerido).
Paso 3.- Configuración del jdk
Para configurar el JDK de Java, se procedió pulsando el botón derecho del mouse
sobre "Mi PC" para activar "Propiedades" del menú desplegable. Se seleccionó la
pestaña "Opciones avanzadas" y se pulsó en el botón inferior "Variables de entorno".
Tanto en el cuadro superior “Variables de usuario…” como el inferior “Variables del
sistema”, se localizó una variable que se llama "Path", se hizo clic sobre ella y se
pulsó el botón "Modificar".
56
En el cuadro de “Valor de variable”, se agregó esta instrucción al final: Otras
instrucciones...;C:\Archivos de programa\Java\jdk1.5.0_07\bin.
Se pulsó el botón ACEPTAR. Se procedió a salir de “Variables de entorno” y
“Propiedades del sistema”. Se abrió la "Consola del Sistema", también llamada
"Símbolo del Sistema". Habitualmente se puede encontrar en "Menú Inicio" ->
Programas -> Accesorios. Si no se encuentra, también se puede abrir con "Menú
Inicio" -> Ejecutar, luego escribir "cmd" y pulsar ACEPTAR. En el símbolo del
sistema, se escribió:
Java
Y se pulsó la tecla “ENTER”. En este punto cabe destacar que si se obtiene un
mensaje donde se muestran las opciones de Java, como en la siguiente figura:
El jdk de Java ya está configurado y listo para usarse.
Si por el contrario aparece un mensaje como este:
57
"java" no se reconoce como un comando interno o externo,
programa o archivo por lotes ejecutable.
Se debe borrar del "Path" todas las variables de entorno que tengan que ver con Java,
revisar que se han seguido todos los pasos correctamente y volver a repetir el
procedimiento.
IV.2.2
Instalación del lenguaje de aspectos (AspectJ)
Para desarrollar, tejer (weaving), compilar y ejecutar las clases que conforman
el código base (requisitos funcionales) y el aspecto (requisitos no funcionales) para
evaluar los beneficios de la POA, fue necesario además de Java, instalar AspectJ
como lenguaje de aspectos. En este caso se utilizó AspectJ Development
Environment (AJDE) versión 1.5.2.
Paso 1.- Instalación del AspectJ
Para instalar AspectJ AJDE 1.5.2, se necesita tener instalada una versión de Java
previamente.
Se ejecutó el programa de instalación "aspectj-1.5.2.jar" que está en la carpeta
AspectJ AJDE 1.5.2 del CD que acompaña este trabajo.
AspecJ es una herramienta de uso libre que se puede descargar del sitio web:
http://eclipse.org.aspectj/.
Seguidamente aparece el instalador y se pulsó el botón “Next” para continuar.
58
Se seleccionó la máquina virtual de Java a ejecutar, que está en el directorio donde se
instala Java y se pulsó el botón “Next” para continuar.
Se eligió el directorio de trabajo y se pulsó el botón “Install”.
59
Se siguieron las instrucciones hasta que se comenzaron a copiar todos los archivos.
Cuando terminó la instalación, se pulsó el botón de finalización y se dispuso a
reiniciar el equipo (sólo si es requerido).
Paso 2.- Configuración de AspectJ
Para configurar AspectJ, se procedió pulsando el botón derecho del mouse sobre "Mi
PC" para activar "Propiedades" del menú desplegable. Se seleccionó la pestaña
"Opciones avanzadas" y se pulsó en el botón inferior "Variables de entorno".
Tanto en el cuadro superior “Variables de usuario…” como el inferior “Variables del
sistema”, se localizó una variable que se llama "Path", se hizo clic sobre ella y se
pulsó el botón "Modificar". En el cuadro de “Valor de variable”, se agregó esta
instrucción al final: Otras instrucciones...;C:\aspectj1.5\bin.
Se pulsó el botón ACEPTAR. Se procedió a salir de “Variables de entorno” y
“Propiedades del sistema”. En el directorio de instalación, se encuentra el entorno de
desarrollo de AspectJ.
60
Se ejecutó el archivo “ajbrowser.bat”. El aspecto inicial es el siguiente:
Se agregó sólo esta línea en "Tools" -> "Options" -> "AJBrowser Options" en
"Classpath (defaults to current directory): "C:\aspectj1.5\lib\aspectjrt.jar".
AspectJ ya está configurado y listo para usarse.
61
IV.3. Diseño del caso de estudio
El caso de estudio se centra sobre una realidad hipotética en el contexto de un
sistema para la inscripción regular de estudiantes de una universidad denominada
“Universidad Nacional”. Las operaciones implícitas en el proceso de inscripción,
parten del conocimiento y experiencia por parte de los investigadores, a partir del
contacto diario con situaciones reales en otros contextos (UDO, UNA, UCV, entre
otros), las cuales son extraídas de manera conveniente para desarrollar el caso de
estudio. El proceso de inscripción al que se hace referencia parte de tres etapas: La
primera comprende la selección de las asignaturas por parte del estudiante, previa oferta
hecha por la universidad de acuerdo a los pensum de estudio y al histórico o record de
calificaciones del estudiante. La segunda consiste en el registro de la inscripción por parte del
estudiante que consta de la carga académica a cursar y el cumplimiento de los requisitos
exigidos por la universidad, y por último la etapa de validación de la inscripción del
estudiante que realiza el departamento de Control de Estudio en representación de la
universidad con la finalidad de cerrar el proceso de manera formal. Los directivos de la
Universidad han enfatizado, que por problemas presentados anteriormente asociados al
proceso de inscripción, se hace necesario incorporar al sistema mecanismos que permitan
entre otras cosas la seguridad e integridad de los datos críticos registrados, previniendo el
acceso a los mismos por personas no autorizadas; así mismo, contemplar planes de
contingencia que permitan el funcionamiento de las operaciones mas importantes en caso de
que estas se produjeran.
Entre las funciones principales que el sistema debe abarcar están las siguientes:
62
1.- Registrar las asignaturas que conforman los pensum de las carreras que ofrece la
universidad y que estos datos queden almacenados en una base de datos, donde se
especifique código, nombre y unidades crédito de la asignatura. Debe contemplarse
que el sistema no permita la creación de asignaturas con código repetido.
2.- Registrar las matrices curriculares de los pensum de las carreras que ofrece la
universidad y que estos datos queden almacenados en una base de datos, donde se
especifique código de la carrera, nombre de la carrera, código de la asignatura,
nombre de la asignatura, unidades crédito de la asignatura, semestre a la cual
pertenece la asignatura y prerrequisitos.
4.- Registrar los datos personales de los estudiantes de la universidad, tomando en
cuenta que no exista duplicidad. Estos datos deben quedar almacenados en una base
de datos, donde se especifique cédula de identidad, nombre del estudiante, carrera,
dirección, teléfono, correo electrónico, fecha de nacimiento, centro local, etc. Esta
función es considerada crítica y debe protegerse contra posibles fallas que pongan en
peligro la prestación de este servicio y evitar que terceras personas puedan visualizar
o acceder a información del estudiante considerada confidencial (nombre del
estudiante).
3.- Registrar las calificaciones del histórico de notas de los estudiantes de la
universidad y que estos datos queden almacenados en una base de datos, donde se
especifique cédula de identidad, asignatura, calificación, lapso, etc. Esta función debe
protegerse contra posibles fallas que pongan en peligro la prestación de este servicio
y evitar el ingreso de datos erróneos que atenten contra la integridad.
4.- Realizar el proceso de selección de asignaturas de los estudiantes para la
inscripción y que estos datos queden almacenados en una base de datos, donde se
63
especifique cédula de identidad, asignatura, lapso, etc. La oferta de asignaturas se
debe ofrecer de acuerdo al pensum de estudio de la carrera en la cual está inscrito el
estudiante y de acuerdo al cumplimiento de los prerrequisitos exigidos en los pensum
previa comparación con el histórico de notas del estudiante. Para esta función es
necesario evitar el ingreso de datos erróneos y garantizar la prestación del servicio.
5.- Realizar el proceso de registro de inscripción de los estudiantes y que estos datos
queden almacenados en una base de datos, donde se especifique entidad bancaria
donde se deposita el arancel de inscripción, número del baucher, monto del depósito
y fecha del depósito. Esta función debe protegerse de fallas que pongan en peligro la
disponibilidad del servicio e impedir la generación de errores cuando se ingresa la
data.
6.- Imprimir la planilla de inscripción de los estudiantes para su posterior
conformación.
7.- Realizar el proceso de validación de inscripción de los estudiantes y que estos
datos queden almacenados en una base de datos, donde se especifique la
conformación por parte del administrador del sistema de entidad bancaria donde se
deposita el arancel de inscripción, número del baucher, monto del depósito y fecha
del depósito, evitando que no se produzcan errores que afecten la integridad de los
datos y que el servicio esté siempre disponible.
10.- Registrar los usuarios del sistema y que estos datos queden almacenados en una
base de datos, donde se especifique cédula de identidad, nombre usuario, nombre
completo del usuario, contraseña y nivel de acceso. Esta función debe considerar la
disponibilidad del servicio, evitar el ingreso de datos erróneos y que terceras personas
64
puedan visualizar información de los usuarios considerada confidencial (nombre de
usuario y contraseña).
IV.4. Solución al caso de estudio
Para la construcción del sistema base, se tomó como punto de partida el análisis
y diseño orientado a objetos usando UML propuesto por Kendall & Kendall en [7]
basado en la metodología clásica de Ciclo de Vida para el desarrollo de Sistemas la
cual comprende las siguientes fases:
• Investigación preliminar.
• Determinación de los requerimientos del sistema.
• Diseño del sistema.
• Desarrollo del software.
• Prueba de los sistemas.
• Implantación y evaluación.
IV.4.1
Investigación preliminar
La investigación preliminar de este trabajo consistió en conocer las etapas que
se llevan a cabo en el proceso de inscripción regular de una universidad. Con este
propósito se consultó de fuentes directas, visitando y haciendo entrevistas no
estructuradas al personal que labora en las oficinas de control de estudio de las
universidades e institutos de educación superior de la localidad, y se constató que
65
básicamente el proceso de inscripción consiste de tres etapas: La selección de las
asignaturas por parte del estudiante, previa oferta hecha por la universidad de acuerdo
a los pensum de estudio y al histórico o record de calificaciones del estudiante. El
registro de la inscripción por parte del estudiante que consta de la carga académica a
cursar y el cumplimiento de los requisitos exigidos por la universidad. Por último está
la etapa de validación de la inscripción del estudiante por parte de la universidad con
la finalidad de cerrar el proceso de manera formal.
IV.4.2
Requerimientos del sistema
El aspecto fundamental del análisis del sistema y la determinación de los
requerimientos, fue trabajar con los empleados de la oficina de control de estudio de
la universidad. Se hicieron entrevistas no estructuradas al personal involucrado en el
proceso de inscripción. Se revisaron y analizaron los formatos y planillas de
inscripción para determinar los requisitos funcionales y no funcionales del sistema de
inscripción base de este caso de estudio.
Los requisitos funcionales comprende la funcionabilidad básica del sistema,
que está integrada por todos los procesos derivados de las necesidades de los
usuarios. Los requisitos no funcionales comprende la incorporación del concern
“Seguridad”, que le brindará al sistema atributos de confiabilidad, confidencialidad y
disponibilidad, los cuales se describirán más adelante.
66
IV.4.2.1
Requisitos funcionales
1.- Registrar las asignaturas que conforman los pensum de las carreras que ofrece la
universidad.
2.- Registrar las matrices curriculares de los pensum de las carreras que ofrece la
universidad.
4.- Registrar los datos personales de los estudiantes de la universidad.
3.- Registrar las calificaciones del histórico de notas de los estudiantes de la
universidad.
4.- Realizar el proceso de selección de asignaturas de los estudiantes para la
inscripción.
5.- Realizar el proceso de registro de inscripción de los estudiantes.
6.- Imprimir la planilla de inscripción de los estudiantes para su posterior
conformación.
7.- Realizar el proceso de validación de inscripción de los estudiantes.
10.- Registrar los usuarios del sistema.
67
IV.4.2.2
Requisitos no funcionales
1.- Debe contemplarse que el sistema no permita la creación de asignaturas con
código repetido.
2.- Se debe tomar en cuenta que no exista duplicidad en los datos de los estudiantes.
La función de ingresar estudiantes es considerada crítica y debe protegerse contra
posibles fallas que pongan en peligro la prestación de este servicio y evitar que
terceras personas puedan visualizar o acceder a información del estudiante
considerada confidencial (nombre del estudiante).
3.- La función para registrar el histórico del estudiante debe protegerse contra
posibles fallas que pongan en peligro la prestación de este servicio y evitar el ingreso
de datos erróneos que atenten contra la integridad.
4.- Para la función de selección de asignaturas es necesario evitar el ingreso de datos
erróneos y garantizar la prestación del servicio.
5.- El registro de la inscripción debe protegerse de fallas que pongan en peligro la
disponibilidad del servicio e impedir la generación de errores cuando se ingresa la
data.
6.- La función de validación de la inscripción debe contemplar que no se produzcan
errores que afecten la integridad de los datos y que el servicio esté siempre
disponible.
7.- Cuando se registren usuarios al sistema se debe considerar la disponibilidad del
servicio, evitar el ingreso de datos erróneos y mantener la confidencialidad.
68
IV.4.2.3
Requisitos funcionales vs. Requisitos no funcionales
Acceso
Registro de
asignaturas
Integridad
Disponibilidad
Confidencialidad
X
X
X
X
X
X
Registro de
Pensum
Registro
datos
personales de
estudiantes
Registro
histórico de
calificaciones
Selección de
asignaturas
X
Registro de
inscripción
X
X
Imprimir la
planilla de
inscripción
Registro de
validación de
inscripción
Registro de
usuarios
X
X
X
X
X
69
IV.4.3 Diseño del sistema
IV.4.3.1
Modelo de caso de uso
El modelo de caso de uso describe lo que hace el sistema sin describir cómo lo
hace, es decir, es el modelo lógico del sistema. Refleja la vista del sistema desde la
perspectiva de un usuario fuera del mismo (requerimientos). Cada diagrama de caso
de uso está compuesto por dos actores (administrador y estudiante) quienes inician el
evento, el evento que activa el caso de uso y el caso de uso que desempeña las
acciones activadas por el evento. Los casos de uso y los escenarios de caso de uso
para cada función se encuentran en el aneo No. 1.
Registrar
asignatura
<<Incluir>> <<Incluir>>
<<Incluir>>
Registrar
pensum
Registrar
estudiante
<<Incluir>>
Verificar
identidad
<<Incluir>>
<<Incluir>>
Registrar
usuarios
Administrador
Registrar
histórico
<<Incluir>>
<<Incluir>>
Seleccionar
asignaturas
Registrar
inscripción
Estudiante
70
IV.4.3.2
Diagrama de clases
71
IV.4.3.3
Diagrama de secuencia
Los Diagramas de Secuencias representan una interacción entre objetos de
manera secuencial en el tiempo. Muestra la participación de objetos en la interacción
entre sus “líneas de vida” (desde que se instancian) y los mensajes que ellos
organizadamente intercambian en el tiempo. El responsable o ACTOR es quien inicia
el ciclo interactuando inicialmente con la interfaz de usuario: GUI; en seguida se
inician todos los objetos que intervienen en el funcionamiento de la aplicación. En
este diagrama se comienza a observar el comportamiento del sistema a partir de los
eventos generados por los actores. Los diagramas de secuencia para cada función se
encuentran en el aneo No. 2.
Diagrama verificar identidad (1)
::Password
::ControlPassword
::MenuAdministrad
::ConexionODBC
Administrador
Password()
ConexionODBC()
Devuelve la conexión
con el origen de datos
VerificarDatos()
72
IV.4.3.4
Diagrama de actividades
Los diagramas de actividades demuestran las secuencias de actividades de un
proceso. Se utilizan para visualizar, especificar, construir y documentar la dinámica
de un conjunto de objetos o simplemente para modelar el flujo de control de una
operación (método de una clase). Fundamentalmente es un Diagrama de Flujo que
muestra el flujo de control entre las actividades. Los diagramas de actividades para
cada función se encuentran en el aneo No. 3.
Diagrama verificar identidad
Inicio
Usuario y
Contraseña
Obtener
Registro de
Usuario
Usuario y Contraseña
Estado del
Registro
Reingresar datos
Desplegar
mensaje de
error
No encontrado
Encontrado
Cancelar
Desplegar
Menú
Administrador
Fin
Desplegar
Menú
Estudiante
Nivel Administrador
Nivel Estudiante
73
IV.4.3.5
Especificación de requisitos no funcionales
De acuerdo a los requerimientos de seguridad del sistema, y a lo plasmado en la
sección anterior el aspecto estará conformado por tres mecanismos de seguridad: un
mecanismo llamado Excepciones para resguardar la Integridad del sistema, un
mecanismo llamado Operacion para garantizar la Disponibilidad del sistema y un
mecanismo llamado Encriptar para garantizar la Confidencialidad del sistema. Estos
mecanismos atravesarán ortogonalmente a las clases de control en los métodos
comunes a través de “crosscutting” o puntos de insercción.
La función auxiliar a implementar al sistema en estudio consiste en el “Aspecto
Seguridad”, que contiene en su estructura a los “Pointcut”, los “Joint Point” y los
“Advises” términos descritos en el Capítulo I de este trabajo.
Un aspecto “Aspect” se declara de forma similar a una clase. Es la unidad de
código que encapsula los puntos de cortes, avisos, introducciones y declaraciones,
además de sus propios métodos y atributos. La diferencia con una clase es que un
aspecto puede entrecruzar otras clases o aspectos.
Un punto de corte “Pointcut”, permite definir la selección de puntos de unión
(Join Point) dentro del Aspecto.
Los puntos de enlace “Joint Point” son puntos bien definidos en la ejecución de
un programa, entre ellos podemos citar llamadas a métodos y accesos a atributos.
Los avisos “Advises” son acciones que se ejecutan en cada punto de enlace
incluido en un corte. Los avisos tienen acceso a los valores expuestos por el corte.
74
Las tres entidades anteriores son estáticas porque permiten definir
comportamiento adicional que actuará en tiempo de compilación.
Mecanismo para garantizar la integridad del sistema
Las excepciones son la manera de manejar los errores en tiempo de ejecución. La
mayoría de los lenguajes, cuando presentan un error de este tipo lo que hacen es
detener la ejecución del programa. Las excepciones permiten escribir código para
manejar los errores y continuar (si es conveniente) con la ejecución del programa.
pointcut Excepciones(): Maneja los errores en tiempo de ejecución cuando los datos
de entrada no sean correctos, cuando no se encuentre un registro, cuando existan
datos duplicados o errores de tipos de datos a través de las clases de control y así
mantener la integridad de los datos.
Mecanismo para garantizar la disponibilidad del sistema
Los piratas informáticos utilizan programas que causan muchos perjuicios para
registrarse en varias cuentas en un servicio Web o aplicación. Con estas cuentas, los
piratas pueden interrumpir el servicio y causar problemas a los usuarios.
Por ejemplo, los piratas pueden utilizar las cuentas para enviar correo no deseado o
registrar usuarios y datos personales de forma automática, y así producir
congestionamientos que atenten contra la disponibilidad de un sistema.
75
También pueden utilizar programas dañinos para iniciar sesión automáticamente en
cuentas de otros usuarios, cambiar y/o borrar la información suministrada por el
titular correcto de la cuenta causando graves problemas para el mismo.
Para evitar estos inconvenientes se diseñó un mecanismo que obliga a que sea una
persona y no un programa automatizado el que ingrese los datos al sistema. En la
mayoría de los casos, sólo una persona (no un programa) puede reconocer los textos
(números o caracteres) de una imagen. Por esto, este reconocimiento de caracteres y
dígitos en una imagen le proporciona al usuario de este sistema un nivel mayor de
seguridad.
pointcut Operacion(): Ejecuta el método IngresaCaracteres que muestra una imagen
con caracteres, con la finalidad de forzar al operador a escribir estos caracteres para
comprobar que es una persona y no un programa automatizado el que ingresa los
datos a través de las clases de control y así garantizar la disponibilidad del sistema.
Mecanismo para garantizar la confidencialidad del sistema
Con respecto a la privacidad y confidencialidad de los datos, un individuo puede
tener la habilidad para ver, modificar o utilizar la información personal identificable
de cualquier usuario de un sistema. Tal información puede incluir nombre, país,
dirección física, dirección de correo electrónico, número de tarjeta de crédito, número
de seguro social, número de identificación gubernamental. También se le conoce
como información personal o datos personales.
Para evitar que terceras personas puedan ver o acceder a los datos personales. Se
diseñó un mecanismo de encriptamiento de datos que se refiere al proceso de
76
convertir datos en texto cifrado. En el caso del sistema base, los datos que revisten
mayor importancia para su encriptamiento son los nombres de usuario y contraseñas
de acceso al sistema y algunos datos personales de los estudiantes.
pointcut Encriptar(): Ejecuta el método Encriptar que permite encriptar los datos de
mayor importancia para los usuarios del sistema a través de las clases de control y así
garantizar la confidencialidad del sistema.
IV.4.4
Desarrollo del software
Para desarrollar el código base y el aspecto se utilizó el siguiente hardware y
herramientas de programación:
• Microcomputador Portátil con procesador Mobile AMD Sempron 3100+
• Disco duro de 40 Gb
• Memoria RAM de 256 Mb DDR
• Unidad lectora de CD-ROM
• Unidad de reescritura CD-WR
• Monitor XGAF TFT LCD 15”
• Mouse de tres teclas
• Puerto inalámbrico para redes 802.1 b/s gíreles LAN
• Impresora de inyección de tinta (dispositivo de salida)
En cuanto a las herramientas, se utilizó el sistema operativo Windows XP de
Microsoft Corporation. Además del sistema operativo, se utilizó para el diseño y
construcción de la base de datos el manejador de base de datos Microsoft Access
77
2003 de Microsoft Corporation, el lenguaje de programación Java JDK Edition
1.5.0 de Sun Microsystem Corporation para desarrollar el código base, el lenguaje de
propósito general AspectJ versión 1.5.2 de Xerox Park integrado en Eclipse para la
implementación de los aspectos, el decompilador DJ Java Decompiler 3.6 de Atanas
Neshkov.
De acuerdo a los requerimientos del sistema, el código de la aplicación se
desarrolló siguiendo una arquitectura de software por capas, las clases estarán
formadas por clases de interfaz para interactuar con el usuario a través de menús o
cajas de diálogo y capturar los datos, clases de control para hacer las transacciones
propias del sistema desde la interfaz hasta la base de datos donde se hacen los
registros, y una clase de tipo abstracto que servirá para hacer la conexión entre las
clases de control y el origen de datos.
78
Clases de interfaz
Password: Para crear el diálogo que sirve para ingresar usuario y contraseña de
acceso.
MenuAdministrador: Para
crear el menú nivel administrador con todas las
opciones de la aplicación.
MenuEstudiante: Para crear el menú nivel estudiante con sólo las opciones de
inscripción.
Asignaturas: Crea un diálogo que sirve para ingresar datos de asignaturas.
Pensum: Crea un diálogo que sirve ingresar datos de los pensum de estudio.
Estudiantes: Crea un diálogo que sirve para ingresar o mostrar los datos de los
estudiantes.
Historico: Crea un diálogo que sirve para ingresar, cambiar, eliminar o mostrar las
calificaciones del histórico de los estudiantes.
Inscripciones: Crea un diálogo que sirve para ingresar, eliminar o mostrar las
asignaturas seleccionadas por el estudiante para la inscripción.
Validaciones: Crea un diálogo que sirve para validar la inscripción del estudiante.
Usuarios: Crea un diálogo que sirve para ingresar o mostrar los datos de usuario y
contraseña.
Clases de control
ControlPassword: Para trabajar con las funciones que hacen la comprobación de
usuario y contraseña a la base de datos.
ControlAsignaturas: Para trabajar con las funciones que hacen transacciones de los
datos de asignaturas a la base de datos.
ControlPensum: Para trabajar con las funciones que hacen transacciones de los
datos de los pensum de estudio a la base de datos.
79
ControlEstudiantes: Para trabajar con las funciones que hacen transacciones de los
datos personales de los estudiantes a la base de datos.
ControlHistorico: Para trabajar con las funciones que hacen transacciones de los
datos del histórico de notas de los estudiantes a la base de datos.
ControlInscripciones: Para trabajar con las funciones que hacen transacciones de las
asignaturas seleccionadas por los estudiantes a la base de datos.
ControlValidaciones: Para trabajar con las funciones que hacen transacciones de las
validaciones y registros de inscripción de los estudiantes a la base de datos.
ControlUsuarios: Para trabajar con las funciones que hacen transacciones de los
datos de los usuarios a la base de datos.
Clases abstractas
Java.awt.JFrame: Clase del paquete de librerías estándar de Java para crear Frames
o ventanas de interfaz.
Java.awt.JDialog: Clase del paquete de librerías estándar de Java para crear Cajas de
Diálogos de interfaz.
ConexionODBC: Para hacer la conexión entre las clases de control y el origen de
datos.
Aspecto (aspect)
AspectoSeguridad: Para crear el aspecto SEGURIDAD con los atributos: Integridad,
Disponibilidad y Confidencialidad, como requisitos no funcionales comunes para las
clases de control.
80
Puntos de corte (pointcut)
Excepciones: Para crear el mecanismo que garantiza la integridad del sistema
(Advises). Atraviesa ortogonalmente a las clases: ControlPassword, ControlUsuarios,
ControlEstudiantes, ControlAsignaturas, ControlInscripciones, ControlValidaciones
en los métodos VerificarDatos() y BuscarCedula() (Joint Point).
Operacion: Para crear el mecanismo que garantiza la disponibilidad del sistema
(Advises).
Atraviesa
ortogonalmente
a
las
clases:
ControlUsuarios,
ControlEstudiantes, ControlHistorico, ControlInscripciones, ControlValidaciones en
los métodos GuardarDatos() y ActualizarDatos() (Joint Point).
Encriptar: Para crear el mecanismo que garantiza la confidencialidad del sistema
(Advises). Atraviesa ortogonalmente a las clases: ControlPassword, ControlUsuarios,
ControlEstudiantes, en el método IniciarVariables() (Joint Point).
81
IV.4.4.1
Construcción de la base de datos
La base de datos se construyó utilizando la herramienta Microsoft Office
Access 2003 de Microsoft Corporation.
Base de datos: Estudiantes.mdb
Archivo:
Estudiantes.mdb
Ubicación:
Carpeta “TG-319\3-BASE DE DATOS” del CD anexo al informe
Objetivos:
Crear la base de datos y las tablas que manejará el
sistema, definir la estructura de la base de datos y la
normalización.
Tiempo de duración:
1/2 semana
Herramienta utilizada:
Manejador de base de datos Access 2003 de
Microsoft Office 2003 Profesional de Microsoft
Corporation.
Costo estimado:
El costo va a depender de la licencia del software.
Dependencia
Ninguna (es la primera actividad).
(Prelación/Concurrencia):
Lista de entidades de la base de datos
El inventario de entidades muestra los nombres de las tablas que conforman la
base de datos que usará el sistema base para hacer las transacciones propias de un
proceso de inscripción.
USUARIOS: Tabla que contiene los nombres de usuarios y contraseñas.
ESTUDIANTES: Tabla (maestro) que contiene los datos de los estudiantes: cédula,
nombre y apellido, dirección, carrera, sexo, fecha de nacimiento, etc.
82
HISTORICO: Tabla que contiene los datos del histórico de calificaciones del
estudiante.
INSCRIPCIONES: Tabla que almacena los datos de las asignaturas seleccionadas
por el estudiante para la inscripción.
VALIDACIONES: Tabla que almacena los datos del registro de la inscripción del
estudiante, como número del depósito bancario por concepto de aranceles, nombre
del banco, fecha de depósito, monto, etc.
ASIGNATURAS: Tabla para almacenar los datos de todas las asignaturas: código,
nombre de la asignatura y número de créditos.
PENSUM: Tabla que almacena los datos de la matriz curricular de todas las carreras
que ofrece la universidad: código carrera, código asignatura, semestre, pre-requisitos,
etc.
Atributos por entidad, estructura y descripción
En esta sección se representan los campos que conforman las diferentes entidades.
USUARIOS
Nombre del campo
NombreUsuario
NombreCompleto
CedulaUsuario
ClaveUsuario
NivelUsuario
Tipo de datos
Texto
Texto
Número
Texto
Número
Descripción
Nombre del usuario del sistema
Nombre completo del usuario del sistema
Cédula de identidad del usuario
Clave de seguridad del usuario (contraseña)
Nivel de acceso del usuario
83
ESTUDIANTES
Nombre del campo
CedulaEstudiante
NombreEstudiante
FechaNacimiento
SexoEstudiante
DireccionEstudiante
TelefonoEstudiante
CorreoEstudiante
CodigoCarrera
CentroLocal
Tipo de datos
Número
Texto
Fecha/Hora
Texto
Texto
Texto
Texto
Número
Texto
Descripción
Cédula de identidad del estudiante
Nombres y apellidos del estudiante
Fecha de nacimiento del estudiante
Sexo del estudiante (0: Masculino 1:Femenino)
Dirección de habitación del estudiante
Teléfono del estudiante
Correo electrónico del estudiante
Código de la carrera del estudiante
Centro local donde cursa la carrera el estudiante
HISTORICO
Nombre del campo
CedulaEstudiante
CodigoAsignatura
CalificacionAsignatura
LapsoAsignatura
Tipo de datos
Descripción
Número
Cédula de identidad del estudiante
Número
Código de la asignatura
Número
Calificación obtenida
Lapso en que el estudiante obtuvo la
Texto
calificación
INSCRIPCIONES
Nombre del campo
CedulaEstudiante
CodigoCarrera
CodigoAsignatura
LapsoInscripcion
Tipo de datos
Número
Número
Número
Texto
Descripción
Cédula de identidad del estudiante
Código de la carrera del estudiante
Código de la asignatura
Lapso de la inscripción
VALIDACIONES
Nombre del campo
CedulaEstudiante
LapsoInscripcion
BancoDeposito
NumeroDeposito
FechaDeposito
MontoDeposito
ValidacionInscripcion
Tipo de datos
Número
Texto
Texto
Número
Fecha/Hora
Número
Número
Descripción
Cédula de identidad del estudiante
Lapso de la inscripción
Banco donde se realizó el depósito arancel
Número del depósito de los aranceles
Fecha en que se realizó el depósito
Monto del depósito de los aranceles
Valida la inscripción del estudiante
84
ASIGNATURAS
Nombre del campo
CodigoAsignatura
NombreAsignatura
UCAsignatura
Tipo de datos
Descripción
Número
Código de la asignatura
Texto
Nombre de la asignatura
Número
Unidades de crédito de la asignatura
PENSUM
Nombre del campo
CodigoCarrera
CodigoAsignatura
SemestreAsignatura
CodigoPreRequisito1
CodigoPreRequisito2
CodigoPreRequisito3
CodigoPreRequisito4
Tipo de datos
Número
Número
Número
Número
Número
Número
Número
Descripción
Código de la carrera del estudiante
Código de la asignatura
Semestre al cual pertenece la asignatura
Código de pre-requisito de la materia
Código de pre-requisito de la materia
Código de pre-requisito de la materia
Código de pre-requisito de la materia
Relación entre entidades
ESTUDIANTES
CedulaEstudiante NombreEstudiante
FechaNacimiento
SexoEstudiante
DireccionEstudiante
...
HISTORICO
CedulaEstudiante
CodigoAsignatura CalificacionAsignatura
...
LapsoAsignatura
INSCRIPCIONES
CedulaEstudiante
CodigoCarrera
CodigoAsignatura
LapsoInscripcion
...
BancoDeposito
NumeroDeposito
...
VALIDACIONES
CedulaEstudiante
LapsoInscripcion
PENSUM
CodigoCarrera
CodigoAsignatura
SemestreAsignatura CodigoPreRequisito1
ASIGNATURAS
CodigoAsignatura NombreAsignatura
UCAsignatura
...
85
IV.4.4.2
Archivos:
Construcción del código base (clases)
Password.java
ControlPassword.java
MenuAdministrador.java
MenuEstudiante.java
Asignaturas.java
ControlAsignaturas.java
Pensum.java
ControlPensum.java
Estudiantes.java
ControlEstudiantes.java
Historico.java
ControlHistorico.java
Inscripciones.java
ControlInscripciones.java
Validaciones.java
ControlValidaciones.java
Usuarios.java
ControlUsuarios.java
ConexionODBC.java
Ubicación:
Carpeta “TG-319\1-CODIGO BASE-CLASES” del CD anexo al
informe
Objetivos:
Construir el código fuente de las clases que forman el
código base.
Tiempo de duración:
2 semanas
Herramienta utilizada:
Lenguaje de programación Java (JDK Edition 1.5.0)
Costo estimado:
Software de uso libre.
Tiene como prelación la Construcción de la base de
Dependencia
(Prelación/Concurrencia): datos.
El código base se encuentra anexo como la documentación del código base (clases).
Ver anexo No. 4.
86
IV.4.4.3
Archivos:
Construcción del aspecto (requisitos no funcionales)
AspectoSeguridad.java
ArchivoParaTejer.lst
Ubicación:
Carpeta “TG-319\ 2-ASPECTOS” del CD anexo al informe
Objetivos:
Construir el código fuente del aspecto que forma la
función auxiliar del sistema (requisitos no
funcionales)
Tiempo de duración:
2 semanas
Herramienta utilizada:
Lenguaje de aspectos AspectJ (AspectJ versión 1.5.2)
Costo estimado:
Software de uso libre.
Tiene como prelación la Construcción del código base
Dependencia
(Prelación/Concurrencia): (clases).
El código del aspecto se encuentra anexo como la documentación del aspecto. Ver
anexo No. 5.
Para la construcción de las clases hechas en Java (*.java) como para el aspecto
se puede utilizar cualquier editor de textos. En este caso se utilizó el block de notas
de Windows. Para editar una clase de Java con el block de notas de windows:
• Hacer clic con el botón derecho del mouse sobre la clase, ejemplo
“Password.java".
• Del menú que aparece, seleccionar "Abrir con".
• Hacer clic en Block de notas para editar la clase.
87
IV.5. Prueba e implementación
En esta sección se describirá detalladamente los pasos para la implementación
del código de base y la implementación del aspecto (requisitos no funcionales), con la
finalidad de evaluar los resultados y llegar a las conclusiones y recomendaciones
finales de este trabajo con respecto a las ventajas, desventajas, aportes o soluciones
inherentes a esta nueva tecnología.
IV.5.1
Empaquetado e instalación del código base y aspecto
El CD que acompaña a este trabajo contiene todo el código fuente, clases,
aspecto, base de datos y archivos de ayuda del Sistema de Software que sirve como
código base (requisitos funcionales) y del Aspecto Seguridad que sirve de función
auxiliar (requisitos no funcionales). El contenido del CD está dispuesto de la
siguiente manera:
Empaquetado:
Se hizo un empaquetado de los archivos (clases y aspecto) para su instalación
(instalador), con la herramienta INNO SETUP versión 4.0.
Empaquetado con INNO SETUP versión 4.0:
Ubicación en el CD: Raíz del CD (se ejecuta automáticamente o haciendo clic en el
archivo InstalarUNSIRV101.exe).
88
Instalador:
El instalador que se ejecuta por defecto cuando se introduce el CD en la computadora
es el empaquetado hecho con INNO SETUP versión 4.0.
Ubicación en el CD: Raíz del CD (se ejecuta automáticamente cuando se introduce
el CD en la computadora). Los otros archivos que forman parte de este instalador son:
•
autorun.inf (permite la ejecución automática del instalador).
•
UN.ico ( icono que identifica el CD).
•
LEAME.TXT (archivo con las sugerencias para la instalación).
Instalación del sistema
Para instalar el sistema, se debe disponer de una computadora con sistema operativo
Microsoft Windows XP. Introducir el CD que acompaña a este trabajo en la unidad
correspondiente, al cabo de 15 segundos se ejecutará el paquete instalador que se
encuentra en el directorio raíz del CD. Si no se ejecuta la instalación automática, se
debe accesar a la unidad de CD a través del explorador de Windows o “MI PC” y
ejecutar el programa instalador haciendo clic en el archivo Instalar UNSIRV101.exe.
Seguir las instrucciones que se indican en el instalador hasta que aparezca el botón
“Terminar”, si es necesario se debe reiniciar el sistema.
NOTA IMPORTANTE: Este instalador está diseñado y compilado de manera que
copie todas las clases y aspecto necesarias para la ejecución y prueba del sistema, es
importante señalar que se debe tener instalada en el PC la plataforma tecnológica para
la POA (Java y AspectJ en este caso) para el correcto funcionamiento del mismo
como se describe en la sección 4.2 de este capítulo.
89
IV.5.2
Creación del origen de datos
Para utilizar la base de datos “Estudiantes.mdb” y hacer las transacciones
propias de la funcionalidad básica como agregar, modificar y eliminar registros, es
necesario crear el origen de datos. El origen de datos permite hacer la conexión entre
la base de datos y la aplicación base a través del puente JDBC-ODBC.
Qué es JDBC
JDBC (Java DataBase Conectivity), es una interfaz de programación que permite a
los programas Java ejecutar sentencias SQL.
JDBC ya viene incorporado en el JDK (Java Development Kit o Kit de desarrollo de
Java). En este caso se está utilizando el JDK 1.5.0.
Con la tecnología JDBC se puede acceder a DBMS como Oracle, SQL Server, etc., y
existe un driver para cada uno de estos DBMS.
El puente JDBC-ODBC (Open DataBase Conectivity)
Este puente proporciona acceso JDBC API vía uno o más drivers ODBC. Implementa
operaciones JDBC traduciéndolas a ODBC, ODBC las recibe como las operaciones
de un programa aplicativo normal y las implementa en cualquier base de datos para la
cual exista un driver ODBC disponible. En este caso se implementa sobre una base de
datos Microsoft Access 2003.
Gráficamente sería algo como esto:
90
Aplicación Java
Administrador de orígenes de datos (JDBC driver manager)
Controlador
ODBC
driver JDBC
para ODBC
Controlador
ODBC
driver JDBC
para ODBC
Controlador
ODBC
driver JDBC
para ODBC
Origen de
datos X
Origen de
datos Y
Origen de
datos Z
Base de datos
X
Base de datos
Y
Base de datos
Z
Para crear el origen de datos ODBC, primero en “Panel de Control” se abre la opción
“Herramientas administrativas”.
Luego se abre la opción “Orígenes de datos (ODBC).
91
Se selecciona la pestaña “DSN de sistema” y se pulsa el botón “Agregar”.
Se selecciona “Microsoft Access Drives (*.mdb) y se pulsa el botón “Finalizar”.
92
Se crea el nombre del origen de datos “Estudiantes”.
Se pulsa el botón “Seleccionar” para ubicar la base de datos en la carpeta C:\TG319\3-BASE DE DATOS\Estudiantes.mdb.
Para finalizar y crear el origen de datos “Estudiantes” se pulsa el botón ACEPTAR.
IV.5.3
Compilación y ejecución del código base
Una vez instalado los archivos (clases) en la computadora, se pueden compilar
y ejecutar a través del acceso directo que se crea en el escritorio o de forma manual
como se describe más adelante. Para compilar y ejecutar el código base sin aspectos a
través del acceso directo, se debe hacer clic en el icono “UNSIR V.1.0.1.
(S-ASPECTOS)” que se instala en el escritorio, o a través del grupo de programas
UNSIR V.1.0.1.
93
Cómo compilar las clases en java del código base de forma manual
Para compilar y ejecutar clases del código base (requisitos funcionales) con
Java, primero se debe tener instalado correctamente una versión de Java en la
computadora, en este caso "JDK 1.5.0". Para descargar e instalar Java visitar el sitio
web: http://java.sun.com/ o seguir las instrucciones de la sección 4.2 de este capítulo.
Si se tiene instalado Java, de forma correcta, en la computadora, y se instalaron
los archivos de las clases (*.java) en la carpeta de instalación C:\TG-319\1-CODIGO
BASE-CLASES, se debe hacer lo siguiente:
• Ejecutar el archivo por lotes "1Símbolo del sistema (cmd).bat" que se encuentra en
la carpeta C:\TG-319\1-CODIGO BASE-CLASES, haciendo doble clic sobre él
para salir al símbolo del sistema.
• Para compilar una clase, ejemplo "Password.java" (clase principal), desde el
símbolo del sistema escribir lo siguiente: javac Password.java, respetando
mayúsculas y minúsculas y pulsar la tecla ENTER, al cabo de unos segundos se
crearán los archivos compilados de clases (.class).
• Para ejecutar la clase (clase principal que ejecuta el sistema), desde el símbolo del
sistema escribir lo siguiente: java Password y pulsar la tecla ENTER, al cabo de
unos segundos se inicia la aplicación.
Ingreso de nombre de usuario y contraseña de acceso
Para probar la funcionalidad básica cuando se ejecuta el programa, se muestra un
formulario que indica el ingreso del usuario y su contraseña (se puede ingresar al
sistema con el usuario “123” y la contraseña “123” con nivel administrador). Este
94
usuario y contraseña se puede eliminar o modificar en la parte de “Usuarios” del
menú principal, como se describe en el manual de usuario (ver anexo No. 6).
IV.5.4
Compilación y ejecución del código base y aspecto
Una vez instalado los archivos (clases y aspecto) en la computadora, se pueden
compilar y ejecutar a través del acceso directo que se crea en el escritorio o de forma
manual. Para tejer, compilar y ejecutar clases de Java y el aspecto a través del acceso
directo, se debe hacer clic en el icono “UNSIR V.1.0.1. (C-ASPECTOS)” que se
instala en el escritorio, o a través del grupo de programas UNSIR V.1.0.1.
Cómo tejer y compilar las clases en java y el aspecto de forma manual
Para tejer, compilar y ejecutar clases de Java y el aspecto (requisitos no
funcionales), primero se debe tener instalado correctamente una versión de Java en la
computadora, ejemplo " JDK 1.5.0" y una versión de AspectJ, ejemplo "aspectj1.5".
Para descargar e instalar Java visitar el sitio web: http://java.sun.com/ o seguir
las instrucciones de la sección 4.2 de este capítulo.
Para descargar e instalar AspecJ visitar el sitio web: http://eclipse.org.aspectj/ o
seguir las instrucciones de la sección 4.2 de este capítulo.
Si se tiene instalado Java y AspectJ, de forma correcta, en la computadora, y se
instalaron los archivos de las clases y aspecto (*.java) en las carpetas de instalación
C:\TG-319\1-CODIGO BASE-CLASES y C:\TG-319\ 2-ASPECTOS, hacer lo
siguiente:
95
• Ejecutar el archivo por lotes "1Símbolo del sistema (cmd).bat" que se encuentra en
la carpeta C:\TG-319\ 2-ASPECTOS, haciendo doble clic sobre él para salir al
símbolo del sistema.
• En el símbolo del sistema escribir AspectJ y pulsar la tecla ENTER, al cabo de
unos segundos se abre el browser de AspectJ.
• Para tejer, pulse el botón ACEPTAR del mensaje que advierte que se debe cargar
un archivo “*.lst”. Hacer clic en el icono con el signo "+", para abrir el archivo
.lst, "ArchivoParaTejer.lst", que se ubica en la carpeta C:\TG-319\ 2-ASPECTOS.
• Para tejer y compilar, en el menú "Proyect" hacer clic en la opción "Build" y
esperar unos segundos. Se crearán los archivos compilados de clases (.class).
96
• Para ejecutar la aplicación, pulsar el botón con el icono "Options", seleccionar la
pestaña "AjBrowser Options", y escribir el nombre de la clase principal
"Password" en la línea "Run Options" y pulsar el botón "OK".
• Pulsar el botón con el icono "Run" en el menú principal del browser de AspectJ
para correr la aplicación y ver los cambios que produce el aspecto al código base.
97
IV.5.5
Comparación sistema base con sistema aspectual
De acuerdo a la propiedad de calidad evaluada en este trabajo a través de la
POA, que consistió en la implementación del aspecto “Seguridad” y sus atributos:
Integridad, Disponibilidad y Confidencialidad a la aplicación base, se obtuvieron los
siguientes resultados:
Resultados obtenidos
Clase
ControlPassword
ControlUsuarios
ControlUsuarios
ControlUsuarios
ControlAsignatura
Función básica
Sin aspecto
Con aspecto
Ejecuta el mecanismo de
manejo de excepciones y
Verificar identidad
encriptamiento de datos
para usuario y contraseña
Ejecuta el mecanismo de
manejo de excepciones,
Guarda los datos del
encriptamiento de datos
usuario sin manejo de
para usuario y contraseña y
excepciones,
Registrar usuario
obliga a que sea el usuario
encriptamiento de datos ni
del sistema el que ingresa
mecanismo de operación
los datos a través del
mecanismo de operación
Ejecuta el mecanismo de
manejo de excepciones,
Actualiza los datos del
encriptamiento de datos
usuario sin manejo de
para usuario y contraseña y
Cambiar datos usuario excepciones,
obliga a que sea el usuario
encriptamiento de datos ni
del sistema el que actualiza
mecanismo de operación
los datos a través del
mecanismo de operación
Consulta la lista de usuarios Ejecuta el mecanismo de
Consultar datos usuario del sistema sin mecanismo encriptamiento para la datos
de usuario y contraseña
de encriptamiento
Ejecuta el mecanismo de
Guarda los datos de la
Registrar asignatura
asignatura sin manejo de
manejo de excepciones,
excepciones
para mantener la integridad
Verifica la identidad del
usuario sin manejo de
excepciones y
encriptamiento de datos
98
Resultados obtenidos
Clase
ControlEstudiante
ControlEstudiante
ControlEstudiante
ControlHistorico
ControlHistorico
ControlInscripcion
Función básica
Sin aspecto
Con aspecto
Ejecuta el mecanismo de
manejo de excepciones,
encriptamiento de datos
Guarda los datos del
para el nombre del
estudiante sin manejo de
estudiante y datos
excepciones,
Registrar estudiante
personales confidenciales y
encriptamiento de datos ni
obliga a que sea el usuario
mecanismo de operación
del sistema el que ingresa
los datos a través del
mecanismo de operación
Ejecuta el mecanismo de
manejo de excepciones,
encriptamiento de datos
Actualiza los datos del
para el nombre del
estudiante sin manejo de
estudiante y datos
Cambiar datos
excepciones,
estudiante
personales confidenciales y
encriptamiento de datos ni
obliga a que sea el usuario
mecanismo de operación
del sistema el que actualiza
los datos a través del
mecanismo de operación
Ejecuta el mecanismo de
Consulta los datos
encriptamiento para el
personales del estudiante
Consultar datos
nombre del estudiante y
estudiante
sin mecanismo de
datos personales
encriptamiento
confidenciales
Ejecuta el mecanismo de
Guarda los datos del
manejo de excepciones, y
histórico de notas del
obliga a que sea el usuario
Registrar histórico
estudiante sin manejo de
del sistema el que ingresa
excepciones ni mecanismo
los datos a través del
de operación
mecanismo de operación
Ejecuta el mecanismo de
Actualiza los datos del
manejo de excepciones, y
histórico de notas del
obliga a que sea el usuario
Cambiar datos histórico estudiante sin manejo de
del sistema el que ingresa
excepciones ni mecanismo
los datos a través del
de operación
mecanismo de operación
Guarda los datos de la
Ejecuta el mecanismo de
selección de asignaturas del manejo de excepciones, y
estudiante para la
obliga a que sea el usuario
Seleccionar asignaturas
inscripción sin manejo de
del sistema el que ingresa
excepciones ni mecanismo los datos a través del
mecanismo de operación
de operación
99
Resultados obtenidos
Clase
ControlInscripcion
ControlValidacion
ControlValidacion
ControlValidacion
Función básica
Cambiar selección
Sin aspecto
Cambia y actualiza los
datos de la selección de
asignaturas del estudiante
para la inscripción sin
manejo de excepciones ni
mecanismo de operación
Registrar inscripción
Guarda los datos de la
inscripción del estudiante
sin manejo de excepciones
ni mecanismo de operación
Validar inscripción
Valida y guarda los datos
de la inscripción del
estudiante sin manejo de
excepciones ni mecanismo
de operación
Cambiar validación
Cambia la validación y
actualiza los datos de la
inscripción del estudiante
sin manejo de excepciones
ni mecanismo de operación
Ventajas de la POA
Elimina el efecto de código disperso y enmarañado.
Incrementa la calidad del software produciendo código:
• Mejor Modularizado
• Más fácil de entender
• Más fácil de mantener
• Más reutilizable
• En teoría más barato de producir
Con aspecto
Ejecuta el mecanismo de
manejo de excepciones, y
obliga a que sea el usuario
del sistema el que ingresa
los datos a través del
mecanismo de operación
Ejecuta el mecanismo de
manejo de excepciones, y
obliga a que sea el usuario
del sistema el que ingresa
los datos a través del
mecanismo de operación
Ejecuta el mecanismo de
manejo de excepciones, y
obliga a que sea el usuario
del sistema el que ingresa
los datos a través del
mecanismo de operación
Ejecuta el mecanismo de
manejo de excepciones, y
obliga a que sea el usuario
del sistema el que ingresa
los datos a través del
mecanismo de operación
100
IV.6.
Documentación
La documentación del sistema está formada por los listados con el código
fuente de las clases que conforman el sistema base así como el listado del código
fuente del aspecto, esto con la finalidad de interpretar las líneas de código y tener una
idea del diseño del mismo para posteriores modificaciones o detección de errores.
Ver anexos No. 4 y 5.
El manual del usuario presenta una descripción detallada del funcionamiento
del sistema base, comenzando por la compatibilidad del programa, hardware
necesario para su funcionamiento e instalación del mismo. Describe los pasos a
seguir para cargar los datos a las tablas que conforman el sistema, registrar los datos
de los usuarios y estudiantes, realizar los procesos de selección de asignaturas,
registro y validación de inscripción, documentando en forma detallada el
funcionamiento del menú de opciones y de las pantallas de entrada y edición de
datos. Ver anexo No. 6
101
CONCLUSIONES
• La POA, es una realidad a través de la herramienta AspectJ. Esto implica una gran
ventaja. Si el programador ya sabe programar en Java, prácticamente ya está
programando en AspectJ: es una extensión de Java.
• El Sistema Base o nivel de aplicación se mantiene intacto aún después de la
implementación de los aspectos, permitiendo “conectarse” o “desconectarse”
(plug-in, plug-out) a la funcionalidad básica.
• Es posible reducir el trabajo de mantenibilidad de las aplicaciones Orientadas a
Objeto a través del uso de aspectos.
• Es posible implementar requisitos no funcionales a través de la POA.
• El DSOA es actualmente un campo abierto, donde se están realizando las primeras
experiencias prácticas para mostrar su aplicabilidad, se podría decir que se
encuentra en el mismo lugar del Desarrollo de Software Orientado a Objeto hace
quince años.
102
RECOMENDACIONES
• Formar grupos de investigación para lograr la divulgación y avance de esta nueva
tecnología.
• Desarrollar proyectos de investigación a través de la POA.
• Evolucionar hacia la definición de un proceso de ingeniería de requisitos, diseño
arquitectónico e implementación orientada a aspectos centrado en la calidad del
software.
• Establecer alianzas o sistemas de cooperación entre Centros de Investigación y
Universidades del país y del exterior para el desarrollo y aplicación de tecnologías
de software.
103
GLOSARIO
Acceso: Con respecto a la privacidad, es la habilidad de un individuo para ver,
modificar y refutar lo completa y precisa que pueda ser la información personal
identificable (PII) reunida sobre él o ella. Acceso es un elemento de las Prácticas
Honestas de Información.
Advice: Un advice es el comportamiento ha ser ejecutado en un joint point que ha
sido seleccionado. Un advice ayuda a definir “qué hacer”, es un mecanismo muy
similar a un método, usado para declarar el código que debe ejecutarse en cada joint
point que es capturado por el pointcut.
Análisis y diseño de sistemas: Proceso de examinar una situación dada de una
empresa con la intención de mejorarlo mediante nuevos procedimientos. En la fase de
análisis, se recopila e interpreta, se diagnóstica problemas y se utilizan estos hechos a
fin de mejorar el sistema. En la fase de diseño se planea la forma del nuevo sistema
para remplazar o completar el existente.
Aspecto: Un aspecto se define como una unidad modular diseñada para implementar
un concern, pueden contener en su definición código y las correspondientes
instrucciones de donde y cuando invocarlo.
Base de datos: Colección de datos agrupados debido a la semejanza que pueda
existir entre ellos. Una base de datos está compuesta por muchas tablas.
Cifrado: Es un método de encriptación, que utiliza típicamente una clave predefinida
y un algoritmo para transformar texto simple en texto cifrado
104
Concern (Incumbencia): Se define como una propiedad o punto de interés de un
sistema. La IEEE define los concerns para un sistema como aquellos intereses que
pertenecen al desarrollo del sistema y su operación, o demás aspectos que son
críticos; o importantes para uno o varios stakeholders. Los concerns incluyen
consideraciones asociadas a requisitos No funcionales o propiedades de calidad tales
como: performance, confiabilidad, seguridad, distribución entre otros.
Confidencialidad: La habilidad para mantener en reserva la información.
Contraseña: Es una cadena de caracteres que el usuario escribe para verificar su
identidad en una red o en una PC local.
Crosscutting Concerns (Incumbencias Transversales): son aquellas propiedades
que se reparten a lo largo de todo el código de una aplicación, son conceptos que no
pueden encapsularse dentro de una unidad funcional, debido a que atraviesan todo el
sistema.
Datos: Es un hecho aislado que está situado en un contexto significativo mediante
una o varias operaciones de procesamiento. Es parte fundamental de la información.
Disponibilidad: la predisposición para obtener y/o proveer un servicio correcto.
Información: Es el procesamiento de los datos, que puede proporcionar un
conocimiento o bien el entendimiento de ciertos factores.
Integridad: la ausencia de alteraciones inadecuadas del sistema
105
Joint point: Es cualquier punto de ejecución identificable en un sistema, la llamada a
un método es un joint point y la ejecución de un método también lo es; una
asignación a una variable, la construcción de un objeto, una comparación, un
manejador de excepciones entre otros, son ejemplos que permiten identificar tal
concepto.
Pointcut: Un pointcut o punto de corte es un conjunto de joint points; también se
definen como una estructura diseñada para identificar y seleccionar los join points.
Proceso: Actividad que se ejecuta con el fin de obtener un fin específico. Cadena de
procedimientos que deben realizarse de manera lógica y ordenada para conseguir una
respuesta.
Requisito: Es una propiedad que un sistema debe tener para satisfacer al (los) usuario
(s) del mismo.
Requisitos Funcionales: Son los servicios que debe ofrecer el sistema.
Requisitos No Funcionales: A la calidad con la cual los servicios deben
ser
ofrecidos o a restricciones de como ellos deben ser proporcionados.
Seguridad computacional: Es la disciplina, técnicas y herramientas diseñadas para
ayudar a proteger la confidencialidad, integridad y disponibilidad de información y
sistemas.
Sistema: Conjunto de componentes que interactúan entre sí para alcanzar un objetivo
determinado.
106
Sistema automatizado: Sistema basado en el uso de máquinas o computadoras que
contemplen la realización de ciertos procesos de manera automática.
Sistema de información: Es aquel que designa el movimiento de datos o
información entre los diferentes componentes de un sistema.
107
BIBLIOGRAFÍA
[1]
CABRERA, Erubí (1988). La Tesis Paso a Paso. Primera Edición, 1988.
Caracas. Edit. Dolvia.
[2]
CALDERA, Rafael, Castillo I., Losavio F. y Matteo A. (2006). Modelación
de Requisitos, Aspectos y Calidad de Software. XXXII Conferencia
Latinoamericana de Informática, CLEI 2006. Chile.
[3]
CASTILLO, Isi, Caldera R., Losavio F. y Matteo A. (2006). Caracterización
de Sistemas Fiables basada en un modelo estándar de calidad. XXXII
Conferencia Latinoamericana de Informática, CLEI 2006. Chile.
[4]
DEITEL Harvey M. y Paul J. Deitel (2004). Cómo Programar en Java.
Quinta Edición, 2004. México. Edit. Pearson-Prentice Hall.
[5]
FUENTES Lidia, Ana Moreira y Juan Manuel Murillo (2004). Avances en
Desarrollo de Software Orientado a Aspectos. Actas del Segundo Taller de
Desarrollo de Software Orientado a Aspectos. Escuela Politécnica Universidad
de Extremadura. España.
[6]
FUENTES Lidia, Juan Hernández y Ana Moreira (2003). Desarrollo de
Software Orientado a Aspectos. Actas del Taller de Trabajo en Desarrollo de
Software Orientado a Aspectos. Escuela Politécnica Universidad de
Extremadura. España.
[7]
KENDALL Kenneth E. y Julie E. Kendall (2005). Análisis y Diseño de
Sistemas. Sexta Edición, 2005. México. Edit. Pearson-Prentice Hall.
108
[8]
KICZALES G., J. Lamping, A. Mendhekar, C. Maeda, C. Lopes, J.
Loingtier and J.Irwin (1997). Aspect-Oriented Programming. Xerox Palo Alto
Research Center. USA.
[9]
SCHILT Herbert (2000). C++ Guía de Autoenseñanza. Primera Edición,
2000. México. Edit. MacGraw-Hill.
[10] SCHILT Herbert y James Holmes (2004). El Arte de Programar en Java.
Primera Edición, 2004. México. Edit. MacGraw-Hill.
[11] PÉREZ Jennifer, Tour H. Ali, Isidro Ramos y José A. Carsí (2003).
PRISMA: Arquitectura de
Software Orientado a Aspectos y Basada en
Componentes. Actas del Taller de trabajo en Desarrollo de Software Orientado
a Aspectos. Escuela Politécnica Universidad de Extremadura. España.
[12] QUINTERO, Antonia (2000). Visión General de la Programación Orientada a
Aspectos. Departamento de Lenguajes y Sistemas Informáticos, Universidad de
Sevilla. España.
[13] UNA, (2002). Manual de Proyecto de Grado. Tercera reimpresión, 2002.
Caracas.
[14] UNA, (1992). Técnicas de Documentación e Investigación I. Primera edición,
1992. Caracas.
[15] Early Aspect Home Page. [on line]. Disponible en: http://www.earlyaspects.net
109
[16] Eclipse Home Page. [on line]. Disponible en: http://eclipse.org/aspectj/
[17] Grupo Aspect-Oriented Software Special Engineering Home Page.
[on line]. Disponible en: http://www.comp.lancs.ac.uk/computing/aop/
[18] Grupo Demeter Home Page. [on line]. Disponible en:
http://www.ccs.neu.edu/home/lieber/demeter.html
[19] Grupo Evolution Home page. [on line]. Disponible en:
http://www.cse.ucsd.edu/users/wgg/swevolution.html
[20] Grupo de Investigación de Ingeniería de Software Universidad British
Columbia Home Page. [on line]. Disponible en: http://www.cs.ubc.ca/labs/se
[21] Grupo Quercus Home Page. [on line]. Disponible en:
http://quercusseg.unex.es
[22] Grupo TecComm Home Page. [on line]. Disponible en:
http://www.teccomm.les.inf.puc-rio.br/SoCagents/index.htm
[23] Grupo TRESE. Departamento Ciencias de la Computación Universidad
TWENTE. [on line]. Disponible en:
http://trese.cs.utwente.nl/oldhtml/homepage_body.htm
110
[24] Java Download Center. [on line]. Disponible en:
http://www.java.com/es/download/
[25] Java Home Page. [on line]. Disponible en: http://java.sun.com/
[26] KICILLOF, Nicolás (2006). Programación Orientada a Aspectos (AOP).
[on line]. Disponible en:
http://www.microsoft.com/spanish/msdn/comunidad/mtj.net/voices/art152.asp
[27] TANTER, Eric. Más allá de la Orientación al Objeto, Reflexión,
Metaprogramación y Programación por Aspectos. [on line]. Disponible en:
http://www.dcc.uchile.cl/~etanter/courses/tanter-jcc02.pdf
[28] Xerox
PARC,
USA
Home
Page.
[on
line].
Disponible
en:
http://www.parc.xerox.com/
[29] SOMMERVILLE I. y Sawyer, P. Requirements Engineering. A Good
Practice Guide. John Wiley and Sons, New Cork, 1997.
[30] LORENTE L. Mariano, Fernando Asteasuain y Bernardo Ezequiel
Contreras. Programemos en AspectJ. 2005.
[31] MÁRQUEZ, José M. Ingeniería del software. 2005. Universidad de Valladolid
[on line]. Disponible en: http://www.infor.uva.es/
111
[32] WIKIPEDIA. Enciclopedia. [on line]. Disponible en: http://es.wikipedia.org/
[33] REINA A. Visión General de la Programación Orientada a Aspectos. Informe
Interno Nº 2000-11. Departamento de Lenguajes y Sistemas Informática,
Universidad de Sevilla. 2000.
[34] LADDAD R. AspectJ IN ACTION. Practical Aspect-Oriented Programming.
Manning Publications. 2003.
[35] Workshop on Multi-Dimensional Separation of Concerns. International
Conference on Software Engineering, ICSE 2000 [on line]. Disponible en:
www.research.ibm.com/hyperspace/workshops/icse2000
[36] AspectJ Home Page [on line]. Disponible en: www.aspectj.org
[37] GAMAROD [on line]. Disponible en: www.gamarod.com.ar
[38] Tecnologías
Java
Open
oness.sourceforge.net/proyecto
Source
[on
line].
Disponible
en:
112
ANEXOS
1. Modelos de casos de uso.
2. Diagrama de secuencias.
3. Diagrama de actividades.
4. Documentación del código base (clases).
5. Documentación del aspecto.
6. Manual del usuario del sistema.
ANEXO 1
MODELOS DE CASOS DE USO
Diagrama registro de asignaturas
<<Incluir>>
Verificar
identidad
<<Incluir>>
Registrar
asignatura
Cambiar datos
asignatura
Administrador
<<Incluir>>
Eliminar
asignatura
Diagrama registro de pensum
<<Incluir>>
Verificar
identidad
<<Incluir>>
Registrar
pensum
Cambiar datos
pensum
Administrador
<<Incluir>>
Eliminar datos
pensum
Diagrama registro de estudiante
<<Incluir>>
Verificar
identidad
<<Incluir>>
Registrar
estudiante
Cambiar datos
estudiante
Administrador
<<Incluir>>
Eliminar
estudiante
<<Incluir>>
Consultar datos
estudiante
Estudiante
Diagrama registro de histórico
Registrar
histórico
<<Incluir>>
Verificar
identidad
<<Incluir>>
Cambiar datos
histórico
Administrador
<<Incluir>>
Eliminar
histórico
<<Incluir>>
Consultar
histórico
Estudiante
Diagrama selección de asignaturas
Estudiante
Verificar
identidad
<<Incluir>>
<<Incluir>>
Seleccionar
asignaturas
Cambiar
selección
Administrador
<<Incluir>>
Eliminar
selección
Diagrama registro de inscripción
<<Incluir>>
Verificar
identidad
<<Incluir>>
Validar
inscripción
Cambiar
validación
Administrador
<<Incluir>>
Eliminar
validación
<<Incluir>>
Registrar
inscripción
Estudiante
Diagrama registro de usuario
<<Incluir>>
Verificar
identidad
<<Incluir>>
Registrar
usuario
Cambiar datos
usuario
Administrador
<<Incluir>>
Eliminar
usuario
<<Incluir>>
Consultar datos
usuario
Escenarios de casos de uso
Nombre del caso de uso: Verificar identidad
Clase: ControlPassword
Área: Sistema del administrador y estudiante
Actor(es): Administrador y Estudiante
Descripción: Permite al administrador y al estudiante ingresar al sistema
Activar evento: El administrador o estudiante introducen el nombre de usuario y
contraseña y pulsan el botón Aceptar
Pasos desempeñados
Información para los pasos
1. El administrador o estudiante se
conectan al servicio que activa el sistema
Nombre de usuario y contraseña
2. Se lee y verifica el usuario y contraseña
Usuario y contraseña
3. Si el usuario es nivel administrador se
despliega el menú principal con todas las
opciones del sistema
Interfaz Menú del administrador
4. Si el usuario es nivel estudiante se
despliega el menú principal
Interfaz Menú del estudiante
Nombre del caso de uso: Registrar asignatura
Clase: ControlAsignatura
Área: Sistema del administrador
Actor(es): Administrador
Descripción: Permite al administrador registrar los datos de una asignatura
Activar evento: El administrador selecciona la opción Asignaturas del menú e ingresa
los datos como: código de la asignatura, nombre de la asignatura y número de créditos
Pasos desempeñados
Información para los pasos
1. El administrador ingresa los datos de la
asignatura y pulsa el botón Aceptar
Código asignatura, nombre asignatura y
número de créditos
2. Se leen y registran los datos de la
asignatura en la base de datos
Registro de la asignatura
Nombre del caso de uso: Cambiar datos asignatura
Clase: ControlAsignatura
Área: Sistema del administrador
Actor(es): Administrador
Descripción: Permite al administrador cambiar los datos de una asignatura
Activar evento: El administrador selecciona la opción Asignaturas del menú y elige una
asignatura del listado para realizar los cambios
Pasos desempeñados
Información para los pasos
1. El administrador cambia los datos de la
asignatura y pulsa el botón Aceptar
Código asignatura, nombre asignatura y
número de créditos
2. Se leen y actualizan los datos de la
asignatura en la base de datos
Registro de la asignatura
Nombre del caso de uso: Eliminar asignatura
Clase: ControlAsignatura
Área: Sistema del administrador
Actor(es): Administrador
Descripción: Permite al administrador eliminar una asignatura
Activar evento: El administrador selecciona la opción Asignaturas del menú y elige una
asignatura del listado para eliminarla
Pasos desempeñados
Información para los pasos
1. El administrador elige una asignatura y
pulsa el botón Eliminar
Registro de la asignatura
2. Se elimina la asignatura de la base de
datos
Registro de la asignatura
Nombre del caso de uso: Registrar pensum
Clase: ControlPensum
Área: Sistema del administrador
Actor(es): Administrador
Descripción: Permite al administrador registrar los datos de la matriz curricular
Activar evento: El administrador selecciona la opción Pensum del menú e ingresa los
datos como: código de la carrera, código de la asignatura, semestre y prerrequisitos
Pasos desempeñados
Información para los pasos
1. El administrador ingresa los datos de la
matriz curricular y pulsa el botón Aceptar
Código de la carrera, ccódigo asignatura,
semestre y prerrequisitos.
2. Se leen y registran los datos de la matriz
curricular en la base de datos
Registro de la matriz curricular
Nombre del caso de uso: Cambiar datos pensum
Clase: ControlPensum
Área: Sistema del administrador
Actor(es): Administrador
Descripción: Permite al administrador cambiar los datos de matriz curricular
Activar evento: El administrador selecciona la opción Pensum del menú y elige un
registro del listado para realizar los cambios
Pasos desempeñados
Información para los pasos
1. El administrador cambia los datos de la
matriz curricular y pulsa el botón Aceptar
Código carrera, código asignatura,
semestre y prerrequisitos
2. Se leen y actualizan los datos de la
matriz curricular en la base de datos
Registro de la matriz curricular
Nombre del caso de uso: Eliminar pensum
Clase: ControlPensum
Área: Sistema del administrador
Actor(es): Administrador
Descripción: Permite al administrador eliminar una asignatura de la matriz curricular
Activar evento: El administrador selecciona la opción Pensum del menú y elige un
registro del listado para eliminarlo
Pasos desempeñados
Información para los pasos
1. El administrador elige una asignatura de
matriz curricular y pulsa el botón Eliminar
Registro de la matriz curricular
2. Se elimina la asignatura de la matriz
curricular en la base de datos
Registro de la matriz curricular
Nombre del caso de uso: Registrar estudiante
Clase: ControlEstudiantes
Área: Sistema del administrador
Actor(es): Administrador
Descripción: Permite al administrador registrar los datos del estudiante
Activar evento: El administrador selecciona la opción Estudiantes del menú e ingresa
los datos como: número de cédula, nombres y apellidos, dirección, carrera, teléfono,
correo electrónico y centro local
Pasos desempeñados
Información para los pasos
1. El administrador ingresa los datos del
estudiante y pulsa el botón Aceptar
Número de cédula, nombres y apellidos,
dirección, carrera, teléfono, correo
electrónico y centro local
2. Se leen y registran los datos del
estudiante en la base de datos
Registro del estudiante
Nombre del caso de uso: Cambiar datos estudiante
Clase: ControlEstudiantes
Área: Sistema del administrador
Actor(es): Administrador
Descripción: Permite al administrador cambiar los datos del estudiante
Activar evento: El administrador selecciona la opción Estudiantes del menú e ingresa el
número de cédula del estudiante para realizar los cambios
Pasos desempeñados
Información para los pasos
1. El administrador cambia los datos del
estudiante y pulsa el botón Aceptar
Número de cédula, nombres y apellidos,
dirección, carrera, teléfono, correo
electrónico y centro local
2. Se leen y actualizan los datos del
estudiante en la base de datos
Registro de estudiantes
Nombre del caso de uso: Eliminar estudiante
Clase: ControlEstudiantes
Área: Sistema del administrador
Actor(es): Administrador
Descripción: Permite al administrador eliminar un estudiante
Activar evento: El administrador selecciona la opción Estudiantes del menú e ingresa el
número de cédula del estudiante para eliminar los datos
Pasos desempeñados
Información para los pasos
1. El administrador visualiza los datos del
estudiante y pulsa el botón Eliminar
Registro de estudiantes
2. Se elimina el estudiante, el histórico, la
selección de asignaturas, la validación y
registro de inscripción y el usuario de la
base de datos
Registro de estudiantes
Nombre del caso de uso: Consultar datos estudiante Clase: ControlEstudiantes
Área: Sistema del administrador y estudiante
Actor(es): Administrador o Estudiante
Descripción: Permite al administrador o al estudiante consultar los datos personales
Activar evento: El administrador selecciona la opción Estudiantes del menú y elige
consultar estudiantes para visualizar los datos. El estudiante selecciona la opción
Consultar Datos Personales del menú para visualizar los datos
Pasos desempeñados
Información para los pasos
1. El administrador o estudiante selecciona
la opción para consultar los datos
Registro de estudiantes
2. El administrador o estudiante visualiza
los datos personales por pantalla y pulsa el
botón Aceptar
Registro de estudiantes
Nombre del caso de uso: Registrar histórico
Área: Sistema del administrador
Actor(es): Administrador
Clase: ControlHistorico
Descripción: Permite al administrador registrar los datos del histórico de notas del
estudiante
Activar evento: El administrador selecciona la opción Histórico del menú e ingresa el
número de cédula del estudiante para vaciar los datos como: código asignatura,
calificación y lapso
Pasos desempeñados
Información para los pasos
1. El administrador ingresa los datos del
histórico de notas del estudiante y pulsa el
botón Aceptar
Código asignatura, calificación y lapso
2. Se leen y registran los datos del
histórico de notas del estudiante en la base
de datos
Registro del histórico
Nombre del caso de uso: Cambiar datos histórico
Área: Sistema del administrador
Actor(es): Administrador
Clase: ControlHistorico
Descripción: Permite al administrador cambiar los datos del histórico de notas del
estudiante
Activar evento: El administrador selecciona Histórico del menú e ingresa el número de
cédula del estudiante para realizar los cambios
Pasos desempeñados
Información para los pasos
1. El administrador cambia los datos del
histórico de notas del estudiante y pulsa el
botón Aceptar
2. Se leen y actualizan los datos del
histórico de notas del estudiante en la base
de datos
Nombre del caso de uso: Eliminar histórico
Área: Sistema del administrador
Actor(es): Administrador
Código asignatura, calificación y lapso
Registro del histórico
Clase: ControlHistorico
Descripción: Permite al administrador eliminar una asignatura del histórico de notas del
estudiante
Activar evento: El administrador selecciona la opción Histórico del menú e ingresa el
número de cédula del estudiante para eliminar los datos
Pasos desempeñados
Información para los pasos
1. El administrador visualiza los datos del
histórico de notas del estudiante,
selecciona una asignatura y pulsa el botón
Eliminar
Registro del histórico
2. Se elimina la asignatura del histórico de
notas el estudiante de la base de datos
Registro del histórico
Nombre del caso de uso: Consultar datos histórico
Área: Sistema del administrador y estudiante
Actor(es): Administrador o Estudiante
Clase: ControlHistorico
Descripción: Permite al administrador o al estudiante consultar los datos del histórico de
notas del estudiante
Activar evento: El administrador selecciona la opción Histórico del menú e ingresa el
número de cédula del estudiante para visualizar los datos. El estudiante selecciona la
opción Consultar Histórico del menú para visualizar los datos
Pasos desempeñados
Información para los pasos
1. El administrador o estudiante selecciona
la opción para consultar los datos
Registro del histórico
2. El administrador o estudiante visualiza
los datos del histórico de notas del
estudiante por pantalla y pulsa el botón
Aceptar
Registro del histórico
Nombre del caso de uso: Seleccionar asignaturas
Área: Sistema del administrador y estudiante
Actor(es): Administrador o Estudiante
Clase: ControlInscripción
Descripción: Permite al administrador o al estudiante hacer la selección de asignaturas
para la inscripción
Activar evento: El administrador selecciona la opción Seleccionar Asignaturas del
menú e ingresa el número de cédula del estudiante para elegir las asignaturas a inscribir.
El estudiante selecciona la opción Seleccionar Asignaturas del menú para elegir las
asignaturas a inscribir.
Pasos desempeñados
Información para los pasos
1. El administrador o el estudiante
selecciona las asignaturas a inscribir de un
listado y pulsa el botón Guardar
Selección de las asignaturas: código,
nombre, semestre, número de créditos
2. Se lee y registra la selección de
asignaturas del estudiante en la base de
datos
Registro de la selección de asignaturas
Nombre del caso de uso: Cambiar selección
Área: Sistema del administrador
Actor(es): Administrador
Clase: ControlInscripción
Descripción: Permite al administrador cambiar la selección de asignaturas del estudiante
para la inscripción
Activar evento: El administrador selecciona la opción Seleccionar Asignaturas del
menú e ingresa el número de cédula del estudiante para cambiar la selección de las
asignaturas a inscribir
Pasos desempeñados
Información para los pasos
1. El administrador cambia la selección de
asignaturas del estudiante y pulsa el botón
Guardar
2. Se lee y actualiza la selección de
asignaturas del estudiante en la base de
datos
Nombre del caso de uso: Eliminar selección
Área: Sistema del administrador
Actor(es): Administrador
Selección de las asignaturas: código,
nombre, semestre, número de créditos
Registro de la selección de asignaturas
Clase: ControlInscripción
Descripción: Permite al administrador eliminar una asignatura de la selección de
asignaturas del estudiante para la inscripción
Activar evento: El administrador selecciona la opción Seleccionar Asignaturas del
menú e ingresa el número de cédula del estudiante para eliminar los datos
Pasos desempeñados
Información para los pasos
1. El administrador visualiza la selección
de asignaturas del estudiante, selecciona
una asignatura y pulsa el botón Eliminar
Registro de la selección de asignaturas
2. Se elimina la asignatura de la selección
de asignaturas del estudiante de la base de
datos
Registro de la selección de asignaturas
Nombre del caso de uso: Validar inscripción
Área: Sistema del administrador
Actor(es): Administrador
Clase: ControlValidaciones
Descripción: Permite al administrador validar el registro de inscripción del estudiante
Activar evento: El administrador selecciona la opción Registrar Inscripción del menú e
ingresa el número de cédula del estudiante para validar el registro de inscripción
Pasos desempeñados
Información para los pasos
1. El administrador valida el registro de
inscripción del estudiante y pulsa el botón
Guardar
Número del depósito bancario por
concepto de arancel, entidad bancaria,
fecha del depósito, monto
2. Se leen y registran los datos el registro
de inscripción del estudiante en la base de
datos
Registro de inscripción
Nombre del caso de uso: Cambiar validación
Área: Sistema del administrador
Actor(es): Administrador
Clase: ControlValidaciones
Descripción: Permite al administrador cambiar la validación y los datos del registro de
inscripción del estudiante
Activar evento: El administrador selecciona Registrar Inscripción del menú e ingresa el
número de cédula del estudiante para realizar los cambios
Pasos desempeñados
Información para los pasos
1. El administrador cambia la validación y
los datos del registro de inscripción del
estudiante y pulsa el botón Guardar
Número del depósito bancario por
concepto de arancel, entidad bancaria,
fecha del depósito, monto
2. Se leen y actualizan los datos de la
validación y los datos del registro de
inscripción del estudiante en la base de
datos
Registro de inscripción
Nombre del caso de uso: Eliminar validación
Área: Sistema del administrador
Actor(es): Administrador
Clase: ControlValidaciones
Descripción: Permite al administrador eliminar la validación y los datos del registro de
inscripción del estudiante
Activar evento: El administrador selecciona la opción Registrar Inscripción del menú e
ingresa el número de cédula del estudiante para eliminar los datos
Pasos desempeñados
Información para los pasos
1. El administrador visualiza la validación
y los datos del registro de inscripción del
estudiante y pulsa el botón Eliminar
Registro de inscripción
2. Se elimina la validación y el registro de
inscripción del estudiante de la base de
datos
Registro de inscripción
Nombre del caso de uso: Registrar inscripción
Área: Sistema del administrador y estudiante
Actor(es): Administrador o Estudiante
Clase: ControlValidaciones
Descripción: Permite al administrador o al estudiante hacer el registro de la inscripción
Activar evento: El administrador selecciona la opción Registrar Inscripción del menú e
ingresa el número de cédula del estudiante para registrar la inscripción. El estudiante
selecciona la opción Registrar Inscripción del menú para registrar la inscripción
Pasos desempeñados
Información para los pasos
1. El administrador o el estudiante hace el
registro de inscripción y pulsa el botón
Guardar
Número del depósito bancario por
concepto de arancel, entidad bancaria,
fecha del depósito, monto
2. Se leen y registran los datos del registro
de inscripción del estudiante en la base de
datos
Registro de inscripción
Nombre del caso de uso: Registrar usuario
Clase: ControlUsuarios
Área: Sistema del administrador
Actor(es): Administrador
Descripción: Permite al administrador registrar los datos del usuario
Activar evento: El administrador selecciona la opción Usuarios del menú e ingresa los
datos como: usuario, nombres y apellidos, número de cédula, contraseña y nivel de
acceso
Pasos desempeñados
Información para los pasos
1. El administrador ingresa los datos del
usuario y pulsa el botón Aceptar
Usuario, nombres y apellidos, número de
cédula, contraseña y nivel de acceso
2. Se leen y registran los datos del usuario
en la base de datos
Registro del usuario
Nombre del caso de uso: Cambiar datos usuario
Clase: ControlUsuarios
Área: Sistema del administrador
Actor(es): Administrador
Descripción: Permite al administrador cambiar los datos del usuario
Activar evento: El administrador selecciona la opción Usuarios del menú e ingresa el
número de cédula del usuario para realizar los cambios
Pasos desempeñados
Información para los pasos
1. El administrador cambia los datos del
usuario y pulsa el botón Aceptar
Usuario, nombres y apellidos, número de
cédula, contraseña y nivel de acceso
2. Se leen y actualizan los datos del usuario
Registro del usuario
en la base de datos
Nombre del caso de uso: Eliminar usuario
Clase: ControlUsuarios
Área: Sistema del administrador
Actor(es): Administrador
Descripción: Permite al administrador eliminar un usuario
Activar evento: El administrador selecciona la opción Usuarios del menú e ingresa el
número de cédula del usuario para eliminar los datos
Pasos desempeñados
Información para los pasos
1. El administrador visualiza los datos del
usuario y pulsa el botón Eliminar
Registro del usuario
2. Se elimina el usuario de la base de datos
Registro del usuario
Nombre del caso de uso: Consultar datos usuario
Clase: ControlUsuarios
Área: Sistema del administrador
Actor(es): Administrador
Descripción: Permite al administrador consultar los datos del usuario
Activar evento: El administrador selecciona la opción Usuarios del menú y elige
consultar usuarios para visualizar los datos.
Pasos desempeñados
Información para los pasos
1. El administrador selecciona la opción
para consultar los datos
Registro del usuario
2. El administrador visualiza los datos del
usuario por pantalla y pulsa el botón
Aceptar
Registro del usuario
ANEXO 2
DIAGRAMA DE SECUENCIAS
Diagrama verificar identidad (2)
::Password
::ControlPassword
::MenuEstudiante
::ConexionODBC
Estudiante
Password()
ConexionODBC()
Devuelve la conexión
con el origen de datos
VerificarDatos()
Diagrama registrar asignatura
::MenuAdministrad
::Asignaturas
::ControlAsignaturas
::ConexionODBC
Administrador
RegistrarAsignaturas()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
GuardarDatos()
Diagrama cambiar datos asignatura
::MenuAdministrad
::Asignaturas
::ControlAsignaturas
::ConexionODBC
Administrador
RegistrarAsignaturas()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
ActualizarDatos()
Diagrama eliminar asignatura
::MenuAdministrad
::Asignaturas
::ControlAsignaturas
::ConexionODBC
Administrador
RegistrarAsignaturas()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
EliminarDatos()
Diagrama registrar pensum
::MenuAdministrad
::ControlPensum
::Pensum
::ConexionODBC
Administrador
RegistrarPensum()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
GuardarDatos()
Diagrama cambiar datos pensum
::MenuAdministrad
::Pensum
::ControlPensum
::ConexionODBC
Administrador
RegistrarPensum ()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
ActualizarDatos()
Diagrama eliminar pensum
::MenuAdministrad
::Pensum
::ControlPensum
::ConexionODBC
Administrador
RegistrarPensum ()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
EliminarDatos()
Diagrama registrar estudiante
::MenuAdministrad
::Estudiantes
::ControlEstudiantes
::ConexionODBC
Administrador
RegistrarEstudiante()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
GuardarDatos()
Diagrama cambiar datos estudiante
::MenuAdministrad
::Estudiantes
::ControlEstudiantes
::ConexionODBC
Administrador
CambiarEstudiante()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
ActualizarDatos()
Diagrama eliminar estudiante
::MenuAdministrad
::Estudiantes
::ControlEstudiantes
::ConexionODBC
Administrador
EliminarEstudiante()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
EliminarDatos()
Diagrama consultar datos estudiante (1)
::MenuAdministrad
::Estudiantes
::ControlEstudiantes
::ConexionODBC
Administrador
ConsultarEstudiante()
MostrarTabla()
ConexionODBC()
Devuelve la conexión
con el origen de datos
MostrarTabla()
Diagrama consultar datos estudiante (2)
::MenuEstudiante
::Estudiantes
::ControlEstudiantes
::ConexionODBC
Estudiante
DatosPersonales()
Estudiantes()
ConexionODBC()
Devuelve la conexión
con el origen de datos
Estudiantes()
Diagrama registrar histórico
::MenuAdministrad
::Historico
::ControlHistorico
::ConexionODBC
Administrador
HistoricoCalificacio()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
GuardarDatos()
Diagrama cambiar datos histórico
::MenuAdministrad
::Historico
::ControlHistorico
::ConexionODBC
Administrador
HistoricoCalificacio()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
ActualizarDatos()
Diagrama eliminar histórico
::MenuAdministrad
::ControlHistorico
::Historico
::ConexionODBC
Administrador
HistoricoCalificacio()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
EliminarDatos()
Diagrama consultar datos histórico (1)
::MenuAdministrad
::ControlHistorico
::Historico
::ConexionODBC
Administrador
ConsultarHistorico()
Historico()
ConexionODBC()
Devuelve la conexión
con el origen de datos
Historico()
Diagrama consultar datos histórico (2)
::MenuEstudiante
::ControlHistorico
::Historico
::ConexionODBC
Estudiante
ConsultarHistorico()
Historico()
ConexionODBC()
Devuelve la conexión
con el origen de datos
Historico()
Diagrama seleccionar asignaturas (1)
::MenuAdministrad
::Inscripciones
::ControlInscripcion
::ConexionODBC
Administrador
SeleccionarAsig()
Inscripciones()
ConexionODBC()
Devuelve oferta de
asignaturas
Devuelve la conexión
con el origen de datos
IniciarVariables()
VerificarDatos()
GuardarDatos()
Diagrama seleccionar asignaturas (2)
::MenuEstudiante
::Inscripciones
::ControlInscripcion
::ConexionODBC
Estudiante
SeleccionarAsig()
Inscripciones()
ConexionODBC()
Devuelve oferta de
asignaturas
Devuelve la conexión
con el origen de datos
IniciarVariables()
VerificarDatos()
GuardarDatos()
Diagrama cambiar selección
::MenuAdministrad
::Inscripciones
::ControlInscripcion
::ConexionODBC
Administrador
SeleccionarAsig()
Inscripciones()
ConexionODBC()
Devuelve selección de
asignaturas
Devuelve la conexión
con el origen de datos
IniciarVariables()
VerificarDatos()
ActualizarDatos()
Diagrama eliminar selección
::MenuAdministrad
::Inscripciones
::ControlInscripcion
::ConexionODBC
Administrador
SeleccionarAsig()
Inscripciones()
ConexionODBC()
Devuelve selección de
asignaturas
Devuelve la conexión
con el origen de datos
IniciarVariables()
VerificarDatos()
EliminarDatos()
Diagrama validar inscripción
::MenuAdministrad
::Validaciones
::ControlValidacion
::ConexionODBC
Administrador
RegistrarInscripc()
Validaciones()
ConexionODBC()
Devuelve el registro
de inscripción
Devuelve la conexión
con el origen de datos
IniciarVariables()
VerificarDatos()
GuardarDatos()
Diagrama cambiar validación
::MenuAdministrad
::Validaciones
::ControlValidacion
::ConexionODBC
Administrador
RegistrarInscripc()
Validaciones()
ConexionODBC()
Devuelve el registro
de inscripción
Devuelve la conexión
con el origen de datos
IniciarVariables()
VerificarDatos()
ActualizarDatos()
Diagrama eliminar validación
::MenuAdministrad
::Validaciones
::ControlValidacion
::ConexionODBC
Administrador
RegistrarInscripc()
Validaciones()
ConexionODBC()
Devuelve el registro
de inscripción
Devuelve la conexión
con el origen de datos
IniciarVariables()
VerificarDatos()
EliminarDatos()
Diagrama registrar inscripción (1)
::MenuAdministrad
::Validaciones
::ControlValidacion
::ConexionODBC
Administrador
RegistrarInscripc()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
GuadarDatos()
Diagrama registrar inscripción (2)
::MenuEstudiante
::Validaciones
::ControlValidacion
::ConexionODBC
Estudiante
RegistrarInscripc()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
GuadarDatos()
Diagrama registrar usuario
::MenuAdministrad
::ControlUsuarios
::Usuarios
::ConexionODBC
Administrador
RegistrarUsuario()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
GuardarDatos()
Diagrama cambiar datos usuario
::MenuAdministrad
::Usuarios
::ControlUsuarios
::ConexionODBC
Administrador
CambiarUsuario()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
ActualizarDatos()
Diagrama eliminar usuario
::MenuAdministrad
::ControlUsuarios
::Usuarios
::ConexionODBC
Administrador
EliminarUsuario()
IniciarVariables()
VerificarDatos()
ConexionODBC()
Devuelve la conexión
con el origen de datos
EliminarDatos()
Diagrama consultar datos usuario
::MenuAdministrad
::Usuarios
::ControlUsuarios
::ConexionODBC
Administrador
ConsultarUsuarios()
MostrarTabla()
ConexionODBC()
Devuelve la conexión
con el origen de datos
MostrarTabla()
ANEXO 3
DIAGRAMA DE ACTIVIDADES
Diagrama registrar asignatura
Inicio
Código
Nombre
Créditos
Obtener
Registro de
Asignaturas
Código - Nombre - Créditos
Estado del
Registro
Cancelar
Desplegar
mensaje de
error
Reingresar datos
Encontrado
Datos válidos
recibidos
Confirmación
enviada
Fin
Desplegar
confirmación
Actualización
validada
Actualizar
Registro de
Asignaturas
Diagrama cambiar datos asignatura
Inicio
Código
Asignatura
Obtener
Registro de
Asignaturas
Código Asignatura
Estado del
Registro
Cancelar
Reingresar código
Desplegar
mensaje de
error
No encontrado
Datos válidos
recibidos
Fin
Confirmación
enviada
Desplegar
confirmación
Actualización
validada
Actualizar
Registro de
Asignaturas
Diagrama eliminar asignatura
Inicio
Código
Asignatura
Obtener
Registro de
Asignaturas
Código Asignatura
Estado del
Registro
Cancelar
Reingresar código
Desplegar
mensaje de
error
No encontrado
Datos válidos
recibidos
Fin
Confirmación
enviada
Desplegar
confirmación
Eliminación
validada
Eliminar
Asignatura del
Registro
Diagrama registrar pensum
Inicio
Código
Carrera
Semestre
Obtener
Registro de
Pensum
Código - Carrera - Semestre
Estado del
Registro
Cancelar
Reingresar datos
Desplegar
mensaje de
error
Encontrado
Datos válidos
recibidos
Fin
Confirmación
enviada
Desplegar
confirmación
Actualización
validada
Actualizar
Registro de
Pensum
Diagrama cambiar datos pensum
Inicio
Código
Carrera
Asignatura
Obtener
Registro de
Pensum
Código Carrera Asignatura
Estado del
Registro
Cancelar
Reingresar datos
Desplegar
mensaje de
error
No encontrado
Datos válidos
recibidos
Confirmación
enviada
Fin
Desplegar
confirmación
Actualización
validada
Actualizar
Registro de
Pensum
Diagrama eliminar pensum
Inicio
Código
Carrera
Asignatura
Obtener
Registro de
Asignaturas
Código Carrera Asignatura
Estado del
Registro
Cancelar
Reingresar datos
Desplegar
mensaje de
error
No encontrado
Datos válidos
recibidos
Fin
Confirmación
enviada
Desplegar
confirmación
Eliminación
validada
Eliminar
Asignatura del
Registro
Diagrama registrar estudiante
Inicio
Cédula Nombre
Dirección
Teléfono
Obtener
Registro de
Estudiantes
Cédula Nombre Dirección Teléfono
Estado del
Registro
Cancelar
Desplegar
mensaje de
error
Reingresar datos
Encontrado
Datos válidos
recibidos
Confirmación
enviada
Fin
Desplegar
confirmación
Actualización
validada
Actualizar
Registro de
Estudiantes
Diagrama cambiar datos estudiante
Inicio
Número de
Cédula
Obtener
Registro de
Estudiantes
Número de Cédula
Estado del
Registro
Cancelar
Reingresar cédula
Desplegar
mensaje de
error
No encontrado
Encontrado
Fin
Confirmación
enviada
Desplegar
confirmación
Actualizar
Registro de
Estudiantes
Datos válidos
recibidos
Actualización
validada
Cédula Nombre
Dirección
Teléfono
Diagrama eliminar estudiante
Inicio
Número de
Cédula
Obtener
Registro de
Estudiantes
Número de Cédula
Estado del
Registro
Cancelar
Reingresar cédula
Desplegar
mensaje de
error
No encontrado
Datos válidos
recibidos
Confirmación
enviada
Fin
Desplegar
confirmación
Eliminación
validada
Eliminar
Estudiante del
Registro
Diagrama consultar datos estudiante
Inicio
Número de
Cédula
Obtener
Registro de
Estudiantes
Número de Cédula
Estado del
Registro
Cancelar
Reingresar cédula
Desplegar
mensaje de
error
No encontrado
Datos válidos
recibidos
Fin
Desplegar
datos del
estudiante
Diagrama registrar histórico
Inicio
Código
Asignatura
Calificación
Código Asignatura Calificación Lap
Obtener
Registro de
Histórico
Estado del
Registro
Cancelar
Reingresar datos
Desplegar
mensaje de
error
Encontrado
Datos válidos
recibidos
Confirmación
enviada
Fin
Desplegar
confirmación
Actualización
validada
Actualizar
Registro de
Histórico
Diagrama cambiar datos histórico
Inicio
Número de
Cédula
Obtener
Registro de
Histórico
Número de Cédula
Estado del
Registro
Cancelar
Reingresar datos
Desplegar
mensaje de
error
No encontrado
Encontrado
Fin
Confirmación
enviada
Desplegar
confirmación
Actualizar
Registro de
Histórico
Datos válidos
recibidos
Actualización
validada
Código
Asignatura
Calificación
Diagrama eliminar histórico
Inicio
Número de
Cédula
Obtener
Registro de
Histórico
Número de Cédula
Estado del
Registro
Cancelar
Reingresar cédula
Desplegar
mensaje de
error
No encontrado
Datos válidos
recibidos
Confirmación
enviada
Fin
Desplegar
confirmación
Eliminación
validada
Eliminar
Asignatura del
Registro
Diagrama consultar datos histórico
Inicio
Número de
Cédula
Obtener
Registro de
Histórico
Número de Cédula
Estado del
Registro
Cancelar
Reingresar cédula
Desplegar
mensaje de
error
No encontrado
Datos válidos
recibidos
Fin
Desplegar
datos del
Histórico
Diagrama seleccionar asignaturas
Inicio
Número de
Cédula
Obtener
Registro Oferta
Asignaturas
Número de Cédula
Estado del
Registro
Cancelar
No hay selección
Hay selección
Fin
Confirmación
enviada
Desplegar
confirmación
Datos válidos
recibidos
Actualizar
Registro de
Selección
Código
Asignatura
Créditos Sem
Actualización
validada
Diagrama cambiar selección
Inicio
Número de
Cédula
Reingresar cédula
Desplegar
mensaje de
error
Cancelar
Estado del
Registro
No encontrado
Confirmación
enviada
Fin
Obtener
Registro Oferta
Asignaturas
Número de Cédula
Actualizar
Registro de
Selección
Encontrado
Datos válidos
recibidos
Desplegar
confirmación
Actualización
validada
Código
Asignatura
Créditos Sem
Diagrama eliminar selección
Inicio
Número de
Cédula
Obtener
Registro Oferta
Asignaturas
Número de Cédula
Estado del
Registro
Cancelar
Reingresar cédula
Desplegar
mensaje de
error
No encontrado
Datos válidos
recibidos
Confirmación
enviada
Fin
Eliminación
validada
Desplegar
confirmación
Eliminar
Selección del
Registro
Diagrama validar inscripción
Inicio
Número de
Cédula
Reingresar cédula
Desplegar
mensaje de
error
Cancelar
Estado del
Registro
No validada
Confirmación
enviada
Fin
Obtener
Registro de
Inscripción
Número de Cédula
Actualizar
Registro de
Inscripción
Validada
Datos válidos
recibidos
Desplegar
confirmación
Actualización
validada
Num Depósito
Fecha Entidad
Monto
Diagrama cambiar validación
Inicio
Número de
Cédula
Obtener
Registro de
Inscripción
Número de Cédula
Estado del
Registro
Cancelar
No hay cambios
Hay cambios
Fin
Confirmación
enviada
Desplegar
confirmación
Actualizar
Registro de
Inscripción
Datos válidos
recibidos
Num Depósito
Fecha Entidad
Monto
Actualización
validada
Diagrama eliminar validación
Inicio
Número de
Cédula
Obtener
Registro de
Inscripción
Número de Cédula
Estado del
Registro
Cancelar
Reingresar cédula
Desplegar
mensaje de
error
No encontrado
Datos válidos
recibidos
Fin
Confirmación
enviada
Desplegar
confirmación
Eliminación
validada
Eliminar
Registro de
Inscripción
Diagrama registrar inscripción
Inicio
Número de
Cédula
Obtener
Registro de
Inscripción
Número de Cédula
Reingresar cédula
Desplegar
mensaje de
error
Estado del
Registro
Cancelar
Encontrada
Actualizar
Registro de
Inscripción
Confirmación
enviada
Datos válidos
recibidos
Desplegar
confirmación
Fin
No encontrada
Actualización
validada
Num Depósito
Fecha Entidad
Monto
Diagrama registrar usuario
Inicio
Usuario Cédula
Nombre
Contraseña
Usuario Cédula Nombre Contraseña
Obtener
Registro de
Usuarios
Estado del
Registro
Cancelar
Reingresar datos
Desplegar
mensaje de
error
Encontrado
Datos válidos
recibidos
Fin
Confirmación
enviada
Desplegar
confirmación
Actualización
validada
Actualizar
Registro de
Usuarios
Diagrama cambiar datos usuario
Inicio
Número de
Cédula
Obtener
Registro de
Usuarios
Número de Cédula
Estado del
Registro
Cancelar
Reingresar cédula
Desplegar
mensaje de
error
No encontrado
Encontrado
Fin
Confirmación
enviada
Desplegar
confirmación
Actualizar
Registro de
Usuarios
Datos válidos
recibidos
Usuario Cédula
Nombre
Contraseña
Actualización
validada
Diagrama eliminar usuario
Inicio
Número de
Cédula
Obtener
Registro de
Usuarios
Número de Cédula
Estado del
Registro
Cancelar
Reingresar cédula
Desplegar
mensaje de
error
No encontrado
Datos válidos
recibidos
Fin
Confirmación
enviada
Desplegar
confirmación
Eliminación
validada
Eliminar
Usuario del
Registro
Diagrama consultar datos usuario
Inicio
Número de
Cédula
Obtener
Registro de
Usuarios
Número de Cédula
Estado del
Registro
Cancelar
Reingresar cédula
Desplegar
mensaje de
error
No encontrado
Datos válidos
recibidos
Fin
Desplegar
datos del
Usuario
ANEXO 4
DOCUMENTACIÓN DEL CÓDIGO BASE (CLASES)
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: Password (Para crear el diálogo
****
//**** que sirve para ingresar usuario y contraseña de acceso)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
//***************************************************************************
// Inicio Clase Password (Clase principal)
//***************************************************************************
public class Password extends JFrame implements ActionListener
{
//*** Se declaran las variables
static boolean nPass = false;
//*** Se crea una instancia IntUsuarios de la clase ControlPassword para
//*** utilizar los métodos de esta clase
ControlPassword IntUsuarios = new ControlPassword();
//*** Se crean los componentes necesarios
JLabel EtiquetaInUsuario = new JLabel("Usuario :");
static TextField CajaTextoInUsuario = new TextField(10);
JLabel EtiquetaInContrasena = new JLabel("Contraseña :");
static TextField CajaTextoInContrasena = new TextField(10);
ImageIcon imagen = new ImageIcon("C:/TG-319/4-IMAGENES/Usuarios.gif");
JLabel EtiquetaUsuario = new JLabel(imagen);
JButton BotonAceptar = new JButton("
JButton BotonCancelar = new JButton("
Aceptar
");
Cancelar
");
//*** Se define el método principal "main" de la Clase Password
public static void main(String[] args)
{
//*** Se ejecuta el constructor Password de la clase Password
new Password();
}
//*** Inicio del constructor Password
public Password()
{
//*** Se define el título y tamaño de la ventana
setTitle("Usuario y contraseña");
setBounds( 0, 0, 280, 210 );
setResizable(false);
//*** Se cambia el icono de la ventana
setIconImage (new ImageIcon("C:/TG-319/4-IMAGENES/UN.gif").getImage());
//*** Se crean los páneles para acomodar los componentes
JPanel PanelEspacioArriba = new JPanel();
JPanel PanelUsuario = new JPanel(new GridLayout(1,2));
JPanel
JPanel
JPanel
JPanel
JPanel
PanelContrasena = new JPanel(new GridLayout(1,2));
Panel1 = new JPanel(new BorderLayout(5,10));
PanelBotones = new JPanel(new GridLayout(1,2,20,3));
Panel2 = new JPanel(new BorderLayout(5,10));
PanelPrincipal = new JPanel(new FlowLayout(FlowLayout.CENTER));
//*** Etiquetas, cajas de texto y botones del diálogo
CajaTextoInUsuario.setText("");
CajaTextoInContrasena.setEchoChar('*');
BotonAceptar.setMnemonic('A');
BotonAceptar.setToolTipText("Verificar usuario...");
BotonCancelar.setMnemonic('C');
BotonCancelar.setToolTipText("Cancelar y salir...");
PanelEspacioArriba.add(EtiquetaUsuario);
PanelEspacioArriba.setLayout( new FlowLayout(FlowLayout.LEFT));
PanelUsuario.add(EtiquetaInUsuario);
PanelUsuario.add(CajaTextoInUsuario);
PanelContrasena.add(EtiquetaInContrasena);
PanelContrasena.add(CajaTextoInContrasena);
Panel1.add(PanelEspacioArriba, BorderLayout.NORTH);
Panel1.add(PanelUsuario, BorderLayout.CENTER);
Panel1.add(PanelContrasena, BorderLayout.SOUTH);
PanelBotones.add(BotonAceptar);
PanelBotones.add(BotonCancelar);
Panel2.add(Panel1, BorderLayout.NORTH);
Panel2.add(PanelBotones, BorderLayout.SOUTH);
// *** Se agrega el panel principal al diálogo
PanelPrincipal.add(Panel2);
getContentPane().add(PanelPrincipal);
//*** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2),
(pantalla.height - cuadro.height)/2);
//*** Se muestra el diálogo
setVisible(true);
//*** Eventos producidos por los botones de la ventana
addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
BotonAceptar.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
///*******************************
///*** VITAL
****
///*******************************
IntUsuarios.nControl1 = true;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
MenuAdministrador.nControl3 = false;
MenuAdministrador.nControl4 = false;
MenuAdministrador.nControl6 = false;
MenuAdministrador.nControl9 = false;
MenuAdministrador.nControl11 = false;
MenuEstudiante.nControl3 = false;
MenuEstudiante.nControl4 = false;
MenuEstudiante.nControl6 = false;
MenuEstudiante.nControl9 = false;
MenuEstudiante.nControl11 = false;
//*** Se invocan los métodos IniciarVariables-VerificarDatos de la
//*** clase ControlPassword
IntUsuarios.IniciarVariables();
IntUsuarios.VerificarDatos();
if (nPass == true)
dispose();
}
});
BotonCancelar.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
}
//*** Fin del constructor Password
//*** Se definen los métodos necesarios para abrir y cerra el diálogo
public void actionPerformed(ActionEvent e)
{
Object s = e.getSource();
}
public void CierraVentana()
{
setVisible(false);
dispose();
System.exit(0);
}
}
//***************************************************************************
// Fin Clase Password (Clase principal)
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: MenuAdministrador (Para crear el menú del
****
//**** nivel administrador con todas las opciones de la aplicación)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import
import
import
import
import
java.awt.*;
java.awt.event.*;
javax.swing.*;
java.util.Date;
java.awt.Color;
//***************************************************************************
// Inicio Clase MenuAdministrador
//***************************************************************************
public class MenuAdministrador extends JFrame implements ActionListener
{
//*** Se declaran las variables
String
String
String
String
DiaS = "";
Dia = "";
Mes = "";
Ano = "";
String adUsuario = "";
String adNombre = "";
static String adsCedula = "";
static String adsCedula2 = "";
static String adsCedula3 = "";
static String adsCedula4 = "";
int adCedula = 0;
String fechaTotal = String.valueOf(new Date());
static boolean nIMEU = false;
static boolean nMEU = false;
static String nTituloUsuario = "Registrar usuario y contraseña";
static
static
static
static
static
boolean
boolean
boolean
boolean
boolean
nControl3 = true;
nControl4 = true;
nControl6 = true;
nControl9 = true;
nControl11 = true;
static int nEstUsu = 0;
static String Lapso;
//*** Se crean los componentes necesarios
ImageIcon imagen = new ImageIcon("C:/TG-319/4-IMAGENES/FondoUN.jpg");
JLabel EtiquetaMenu = new JLabel(imagen);
JMenuBar Barra = new JMenuBar();
JMenu Archivo = new JMenu("Archivo");
JMenuItem RegistrarAsignaturas = new JMenuItem("Asignaturas");
JMenuItem RegistrarPensum = new JMenuItem("Pensum");
JMenuItem Salir = new JMenuItem("Salir");
JMenu Estudiantes = new JMenu("Estudiantes");
JMenuItem RegistrarEstudiante = new JMenuItem("Registrar datos estudiante...");
JMenuItem CambiarEstudiante = new JMenuItem("Cambiar datos estudiante...");
JMenuItem EliminarEstudiante = new JMenuItem("Eliminar datos estudiante...");
JMenuItem ConsultarEstudiante = new JMenuItem("Consultar estudiantes...");
JMenu Historico = new JMenu("Histórico");
JMenuItem HistoricoCalificaciones = new JMenuItem("Histórico calificaciones estudiante...");
JMenuItem ConsultarHistorico = new JMenuItem("Consultar histórico estudiante...");
JMenu Inscripciones = new JMenu("Inscripciones");
JMenuItem SeleccionarAsignaturas = new JMenuItem("Seleccionar asignaturas de estudiante..");
JMenuItem RegistrarInscripción = new JMenuItem("Registrar y validar inscripción de
estudiante...");
JMenuItem ConsultarInscripciones = new JMenuItem("Consultar estudiantes inscritos...");
JMenu UsuariosSistema = new JMenu("Usuarios");
JMenuItem RegistrarUsuario = new JMenuItem("Registrar usuario y contraseña...");
JMenuItem CambiarUsuario = new JMenuItem("Cambiar usuario y contraseña...");
JMenuItem EliminarUsuario = new JMenuItem("Eliminar usuario y contraseña...");
JMenuItem ConsultarUsuario = new JMenuItem("Consultar usuarios...");
JMenu Ayuda = new JMenu("Ayuda");
JMenuItem AyudaGeneral = new JMenuItem("Ayuda general...");
JMenuItem Acercade = new JMenuItem("Acerca de...");
JLabel
JLabel
JLabel
JLabel
EtiquetaUsuario = new JLabel();
EtiquetaNombre = new JLabel();
EtiquetaCI = new JLabel();
EtiquetaFecha = new JLabel();
//*** Se define el método principal "main" de la Clase MenuAdministrador
public static void main(String[] args)
{
//*** Se ejecuta el constructor MenuAdministrador de la clase MenuAdministrador
new MenuAdministrador();
}
//*** Inicio del constructor MenuAdministrador
public MenuAdministrador()
{
//*** Se define el título y tamaño de la ventana
setTitle("Universidad Nacional: Sistema de Inscripción Regular");
setBounds( 0, 0, 800, 600 );
setResizable(false);
//*** Se cambia el icono de la ventana
setIconImage (new ImageIcon("C:/TG-319/4-IMAGENES/UN.gif").getImage());
//*** Para ejecutar archivos desde java
final Runtime obj = Runtime.getRuntime();
//*** Barra de menú y opciones del menú
setJMenuBar(Barra);
Barra.add(Archivo);
Archivo.add(RegistrarAsignaturas);
Archivo.add(RegistrarPensum);
Archivo.addSeparator();
Archivo.add(Salir);
Barra.add(Estudiantes);
Estudiantes.add(RegistrarEstudiante);
Estudiantes.add(CambiarEstudiante);
Estudiantes.add(EliminarEstudiante);
Estudiantes.add(ConsultarEstudiante);
Barra.add(Historico);
Historico.add(HistoricoCalificaciones);
Historico.add(ConsultarHistorico);
Barra.add(Inscripciones);
Inscripciones.add(SeleccionarAsignaturas);
Inscripciones.add(RegistrarInscripción);
Inscripciones.add(ConsultarInscripciones);
Barra.add(UsuariosSistema);
UsuariosSistema.add(RegistrarUsuario);
UsuariosSistema.add(CambiarUsuario);
UsuariosSistema.add(EliminarUsuario);
UsuariosSistema.add(ConsultarUsuario);
Barra.add(Ayuda);
Ayuda.add(AyudaGeneral);
Ayuda.add(Acercade);
//*** Se asignan las teclas calientes a las opciones del menú
Archivo.setMnemonic('A');
RegistrarAsignaturas.setMnemonic('n');
RegistrarPensum.setMnemonic('P');
Salir.setMnemonic('S');
Estudiantes.setMnemonic('E');
RegistrarEstudiante.setMnemonic('R');
CambiarEstudiante.setMnemonic('C');
EliminarEstudiante.setMnemonic('m');
ConsultarEstudiante.setMnemonic('o');
Historico.setMnemonic('H');
HistoricoCalificaciones.setMnemonic('n');
ConsultarHistorico.setMnemonic('C');
Inscripciones.setMnemonic('I');
SeleccionarAsignaturas.setMnemonic('S');
RegistrarInscripción.setMnemonic('R');
ConsultarInscripciones.setMnemonic('C');
UsuariosSistema.setMnemonic('s');
RegistrarUsuario.setMnemonic('R');
CambiarUsuario.setMnemonic('C');
EliminarUsuario.setMnemonic('E');
ConsultarUsuario.setMnemonic('o');
Ayuda.setMnemonic('u');
AyudaGeneral.setMnemonic('A');
Acercade.setMnemonic('c');
RegistrarAsignaturas.setToolTipText("Tabla de asignaturas");
RegistrarPensum.setToolTipText("Tabla de pensum por carrera");
Salir.setToolTipText("Salir de la aplicación");
RegistrarEstudiante.setToolTipText("Registrar los datos personales del estudiante");
CambiarEstudiante.setToolTipText("Cambiar los datos personales del estudiante");
EliminarEstudiante.setToolTipText("Eliminar los datos personales del estudiante");
ConsultarEstudiante.setToolTipText("Consultar listado de estudiantes");
HistoricoCalificaciones.setToolTipText("Histórico de calificaciones del estudiante");
ConsultarHistorico.setToolTipText("Consultar el histórico de calificaciones del estudiante");
SeleccionarAsignaturas.setToolTipText("Oferta de asignaturas para la inscripción del
estudiante");
RegistrarInscripción.setToolTipText("Registrar y validar la inscripción del estudiante");
ConsultarInscripciones.setToolTipText("Consultar las inscripciones que han sido validadas");
RegistrarUsuario.setToolTipText("Registra los datos de un usuario en el sistema");
CambiarUsuario.setToolTipText("Cambia los datos de un usuario en el sistema");
EliminarUsuario.setToolTipText("Elimina un usuario del sistema");
ConsultarUsuario.setToolTipText("Consultar los usuario del sistema");
AyudaGeneral.setToolTipText("Muestra la ayuda general");
Acercade.setToolTipText("Muestra el diálogo acerca de...");
//*** Etiquetas y cajas de texto en el menú principal
EtiquetaMenu.add(EtiquetaUsuario);
EtiquetaUsuario.setBounds(20, 10, 215, 20);
EtiquetaUsuario.setFont(new Font("SansSerif", Font.BOLD, 16));
EtiquetaUsuario.setForeground( Color.RED);
EtiquetaUsuario.setBackground( Color.WHITE);
EtiquetaMenu.add(EtiquetaNombre);
EtiquetaNombre.setBounds(20, 50, 500, 30);
EtiquetaNombre.setFont(new Font("SansSerif", Font.BOLD, 20));
EtiquetaNombre.setForeground( Color.BLUE);
EtiquetaNombre.setBackground( Color.WHITE);
EtiquetaMenu.add(EtiquetaCI);
EtiquetaCI.setBounds(20, 80, 215, 20);
EtiquetaCI.setFont(new Font("SansSerif", Font.BOLD, 12));
EtiquetaCI.setForeground( Color.BLUE);
EtiquetaCI.setBackground( Color.WHITE);
IniciarEtiquetas(adUsuario,adNombre,adCedula);
//*** Para mostrar la fecha en la ventana del menú
DiaS = fechaTotal.substring(0,3);
Mes = fechaTotal.substring(4,7);
Dia = fechaTotal.substring(8,10);
Ano = fechaTotal.substring(fechaTotal.length() - 4, fechaTotal.length());
//*** Se muestran los días en español
if (DiaS.equals("Sun"))
DiaS = " Domingo";
if (DiaS.equals("Mon"))
DiaS = " Lunes";
if (DiaS.equals("Tue"))
DiaS = " Martes";
if (DiaS.equals("Wed"))
DiaS = " Miércoles";
if (DiaS.equals("Thu"))
DiaS = " Jueves";
if (DiaS.equals("Fri"))
DiaS = " Viernes";
if (DiaS.equals("Sat"))
DiaS = " Sábado";
//*** Se muestran los meses en español
if (Mes.equals("Jan"))
Mes = "Enero";
if (Mes.equals("Feb"))
Mes = "Febrero";
if (Mes.equals("Mar"))
Mes = "Marzo";
if (Mes.equals("Apr"))
Mes = "Abril";
if (Mes.equals("May"))
Mes = "Mayo";
if (Mes.equals("Jun"))
Mes = "Junio";
if (Mes.equals("Jul"))
Mes = "Julio";
if (Mes.equals("Aug"))
Mes = "Agosto";
if (Mes.equals("Sep"))
Mes = "Septiembre";
if (Mes.equals("Oct"))
Mes = "Octubre";
if (Mes.equals("Nov"))
Mes = "Noviembre";
if (Mes.equals("Dec"))
Mes = "Diciembre";
EtiquetaFecha.setText(DiaS + ", " + Dia + " de " + Mes + " de " + Ano);
EtiquetaMenu.add(EtiquetaFecha);
EtiquetaFecha.setBounds(560, 10, 215, 20); //*** (X, Y, Ancho, Alto)
EtiquetaFecha.setFont(new Font("SansSerif", Font.BOLD, 12));
EtiquetaFecha.setForeground(Color.BLUE);
EtiquetaFecha.setBackground(Color.WHITE);
if (Mes.equals("Jan") || Mes.equals("Feb") || Mes.equals("Mar") || Mes.equals("Apr") ||
Mes.equals("May") || Mes.equals("Jun"))
Lapso = Ano + "-1";
else
Lapso = Ano + "-2";
//*** Se agrega la imagen central en la ventana del menú
add(EtiquetaMenu);
//*** Se centra la ventana del menú en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2),
(pantalla.height - cuadro.height)/2);
//*** Se muestra el menú
setVisible( true );
//*** Eventos producidos por las opciones del menú
addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
RegistrarAsignaturas.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase Asignaturas
nIMEU = true;
Asignaturas d = new Asignaturas();
d.setVisible(true);
}
});
RegistrarPensum.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase Pensum
nIMEU = true;
Pensum d = new Pensum();
d.setVisible(true);
}
});
Salir.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
RegistrarEstudiante.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase Estudiante
nIMEU = true;
Estudiantes d = new Estudiantes();
d.setVisible(true);
}
});
CambiarEstudiante.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoCedula
nEstUsu = 1;
nIMEU = true;
nMEU = true;
DialogoCedula d = new DialogoCedula();
d.setVisible(true);
}
});
EliminarEstudiante.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoCedula
nEstUsu = 1;
nIMEU = true;
nMEU = false;
DialogoCedula d = new DialogoCedula();
d.setVisible(true);
}
});
ConsultarEstudiante.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
///*******************************
///*** VITAL
****
///*******************************
nControl4 = false;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = true;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
//*** Se crea una instancia de la clase TablaEstudiante
TablaEstudiantes d = new TablaEstudiantes();
d.setVisible(true);
}
});
HistoricoCalificaciones.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoCedula
nEstUsu = 2;
nIMEU = true;
nMEU = true;
DialogoCedula d = new DialogoCedula();
d.setVisible(true);
}
});
ConsultarHistorico.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoCedula
nEstUsu = 2;
nIMEU = true;
nMEU = false;
DialogoCedula d = new DialogoCedula();
d.setVisible(true);
}
});
SeleccionarAsignaturas.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoCedula
nEstUsu = 3;
nIMEU = true;
nMEU = true;
DialogoCedula d = new DialogoCedula();
d.setVisible(true);
}
});
RegistrarInscripción.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoCedula
nEstUsu = 4;
nIMEU = true;
nMEU = true;
DialogoCedula d = new DialogoCedula();
d.setVisible(true);
}
});
ConsultarInscripciones.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
///*******************************
///*** VITAL
****
///*******************************
ControlValidaciones.nControl12 = true;
ControlUsuarios.nControl2 = false;
ControlPassword.nControl1 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
MenuAdministrador.nControl3 = false;
MenuAdministrador.nControl4 = false;
MenuAdministrador.nControl6 = false;
MenuAdministrador.nControl9 = false;
MenuAdministrador.nControl11 = false;
//*** Se crea una instancia de la clase TablaValidaciones
TablaValidaciones d = new TablaValidaciones();
d.setVisible(true);
}
});
RegistrarUsuario.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase Usuarios
nIMEU = true;
Usuarios d = new Usuarios();
d.setVisible(true);
}
});
CambiarUsuario.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoCedula
nEstUsu = 0;
nIMEU = true;
nMEU = true;
DialogoCedula d = new DialogoCedula();
d.setVisible(true);
}
});
EliminarUsuario.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoCedula
nEstUsu = 0;
nIMEU = true;
nMEU = false;
DialogoCedula d = new DialogoCedula();
d.setVisible(true);
}
});
ConsultarUsuario.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
///*******************************
///*** VITAL
****
///*******************************
ControlUsuarios.nControl2 = true;
ControlPassword.nControl1 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
MenuAdministrador.nControl3 = false;
MenuAdministrador.nControl4 = false;
MenuAdministrador.nControl6 = false;
MenuAdministrador.nControl9 = false;
MenuAdministrador.nControl11 = false;
//*** Se crea una instancia de la clase Usuarios
TablaUsuarios d = new TablaUsuarios();
d.setVisible(true);
}
});
AyudaGeneral.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Ejecuta el archivo de ayuda UNSIR101.HLP
try
{
obj.exec("winhlp32.exe C:/TG-319/5-AYUDA/UNSIR101.HLP");
}
catch (Exception e)
{
System.out.println("Se ha producido un error: "+ e.toString());
}
}
});
Acercade.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoAcercade
DialogoAcercade d = new DialogoAcercade();
d.setVisible(true);
}
});
}
//*** Fin del constructor MenuAdministrador
//*** Se definen los métodos necesarios para abrir y cerrar el menú
public void actionPerformed(ActionEvent e)
{
Object s = e.getSource();
}
public void CierraVentana()
{
setVisible( false );
dispose();
System.exit(0);
}
//*** Se define el método IniciarEtiquetas para mostrar el nombre del usuario y cédula
public void IniciarEtiquetas(String mnuUsuario,String mnuNombre,int mnuCedula)
{
if(mnuUsuario.equals(""))
EtiquetaUsuario.setText("");
else
EtiquetaUsuario.setText("Usuario : " + mnuUsuario);
EtiquetaNombre.setText(mnuNombre);
if(mnuCedula == 0)
EtiquetaCI.setText("");
else
EtiquetaCI.setText("C.I.: " + mnuCedula);
}
//*** Se crea una nueva clase para crear un diáologo que sirve para ingresar
//*** el número de cédula para labores de búsqueda
class DialogoCedula extends JDialog
{
//*** Se crean los componentes necesarios
JLabel EtiquetaCedula = new JLabel("No. de cédula :");
TextField CajaTextoCedula = new TextField(10);
JButton BotonAceptarCedula = new JButton(" Aceptar ");
JButton BotonCancelarCedula = new JButton(" Cancelar ");
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
PanelEspacio = new JPanel();
Panel1 = new JPanel(new GridLayout(1,2));
Panel2 = new JPanel(new BorderLayout(5,10));
Panel3 = new JPanel(new GridLayout(1,2,20,2));
Panel4 = new JPanel(new BorderLayout(5,10));
PanelPrincipal = new JPanel(new FlowLayout(FlowLayout.CENTER));
//*** Constructor de la clase
public DialogoCedula()
{
//*** Se define el título y tamaño de la ventana
super(new Frame(), "Buscar...", true);
setBounds( 0, 0, 280, 155 );
CajaTextoCedula.setText("");
BotonAceptarCedula.setMnemonic('A');
BotonAceptarCedula.setToolTipText("Buscar...");
BotonCancelarCedula.setMnemonic('C');
BotonCancelarCedula.setToolTipText("Cancelar y salir...");
Panel1.add(EtiquetaCedula);
Panel1.add(CajaTextoCedula);
Panel2.add(PanelEspacio, BorderLayout.NORTH);
Panel2.add(Panel1, BorderLayout.SOUTH);
Panel3.add(BotonAceptarCedula);
Panel3.add(BotonCancelarCedula);
Panel4.add(Panel2, BorderLayout.NORTH);
Panel4.add(Panel3, BorderLayout.SOUTH);
PanelPrincipal.add(Panel4);
//*** Se agrega el panel principal al diálogo
getContentPane().add(PanelPrincipal);
//*** Para no cambiar el tamaño de la ventana
setResizable(false);
//*** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
//*** Eventos de los botones
BotonAceptarCedula.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent evt){
if (nEstUsu == 0)
{
//*** Se crea una instancia IntUsuarios de la clase ControlUsuarios
//*** para utilizar los métodos de esta clase
ControlUsuarios IntUsuarios = new ControlUsuarios();
///*******************************
///*** VITAL
****
///*******************************
nControl3 = true;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
MenuAdministrador.nControl4 = false;
MenuAdministrador.nControl6 = false;
MenuAdministrador.nControl9 = false;
MenuAdministrador.nControl11 = false;
adsCedula = CajaTextoCedula.getText();
if (!adsCedula.equals("") && IntUsuarios.BuscarCedula(adsCedula) == true)
{
dispose();
if (nMEU == true)
{
nTituloUsuario = "Cambiar usuario y contraseña";
}
else
{
nTituloUsuario = "Eliminar usuario y contraseña";
}
Usuarios d = new Usuarios();
d.setVisible(true);
}
else
{
nControl3 = false;
}
}
if (nEstUsu == 1)
{
//*** Se crea una instancia IntEstudiantes de la clase ControlEstudiantes o
//*** para utilizar los métodos de esta clase
ControlEstudiantes IntEstudiantes = new ControlEstudiantes();
///*******************************
///*** VITAL
****
///*******************************
nControl4 = true;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
MenuAdministrador.nControl3 = false;
MenuAdministrador.nControl6 = false;
MenuAdministrador.nControl9 = false;
MenuAdministrador.nControl11 = false;
adsCedula = CajaTextoCedula.getText();
if (!adsCedula.equals("") && IntEstudiantes.BuscarCedula(adsCedula) == true)
{
dispose();
if (nMEU == true)
{
Estudiantes d = new Estudiantes();
d.setTitle("Cambiar datos estudiante");
d.setVisible(true);
}
else
{
Estudiantes d = new Estudiantes();
d.setTitle("Eliminar estudiante");
d.setVisible(true);
}
}
else
{
nControl4 = false;
}
}
if (nEstUsu == 2)
{
//*** Se crea una instancia IntHistorico de la clase ControlHistorico
//*** para utilizar los métodos de esta clase
ControlHistorico IntHistorico = new ControlHistorico();
///*******************************
///*** VITAL
****
///*******************************
nControl6 = true;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
MenuAdministrador.nControl3 = false;
MenuAdministrador.nControl4 = false;
MenuAdministrador.nControl9 = false;
MenuAdministrador.nControl11 = false;
adsCedula2 = CajaTextoCedula.getText();
if (!adsCedula2.equals("") && IntHistorico.BuscarCedula(adsCedula2) == true)
{
dispose();
Historico d = new Historico();
d.setVisible(true);
}
else
{
nControl6 = false;
}
}
if (nEstUsu == 3)
{
//*** Se crea una instancia IntInscripciones de la clase ControlInscripciones
//*** para utilizar los métodos de esta clase
ControlInscripciones IntInscripciones = new ControlInscripciones();
///*******************************
///*** VITAL
****
///*******************************
nControl9 = true;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
MenuAdministrador.nControl3 = false;
MenuAdministrador.nControl4 = false;
MenuAdministrador.nControl6 = false;
MenuAdministrador.nControl11 = false;
adsCedula3 = CajaTextoCedula.getText();
if (!adsCedula3.equals("") && IntInscripciones.BuscarCedula(adsCedula3) == true)
{
dispose();
Inscripciones d = new Inscripciones();
d.setVisible(true);
}
else
{
nControl9 = false;
}
}
if (nEstUsu == 4)
{
//*** Se crea una instancia IntValidaciones de la clase ControlValidaciones
//*** para utilizar los métodos de esta clase
ControlValidaciones IntValidaciones = new ControlValidaciones();
///*******************************
///*** VITAL
****
///*******************************
nControl11 = true;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
MenuAdministrador.nControl3
MenuAdministrador.nControl4
MenuAdministrador.nControl6
MenuAdministrador.nControl9
=
=
=
=
false;
false;
false;
false;
adsCedula4 = CajaTextoCedula.getText();
if (!adsCedula4.equals("") && IntValidaciones.BuscarCedula(adsCedula4) == true)
{
dispose();
Validaciones d = new Validaciones();
if (d.MiTabla1.getRowCount() == 0 && !d.CajaTextoVNombre.getText().equals(""))
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Este estudiante no tiene selección de asignaturas !!","Atención",
JOptionPane.WARNING_MESSAGE);
d.CierraVentana();
}
else
d.setVisible(true);
}
else
{
nControl11 = false;
}
}
}
});
BotonCancelarCedula.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
dispose();
}
});
}
//*** Fin del constructor DialogoCedula
}
//*** Fin de la clase DialogoCedula
//*** Se crea una nueva clase para crear un diáologo que sirve para mostrar
//*** los créditos del sistema
class DialogoAcercade extends JDialog
{
//*** Se crean los componentes necesarios
JLabel EtiquetaAcercade0 =
JLabel EtiquetaAcercade1 =
JLabel EtiquetaAcercade2 =
JLabel EtiquetaAcercade3 =
JLabel EtiquetaAcercade4 =
JLabel EtiquetaAcercade5 =
JLabel EtiquetaAcercade6 =
JLabel EtiquetaAcercade7 =
JLabel.CENTER);
JLabel EtiquetaAcercade8 =
JLabel.CENTER);
JLabel EtiquetaAcercade9 =
JLabel EtiquetaAcercade10=
JLabel.CENTER);
JLabel EtiquetaAcercade11=
JLabel.CENTER);
JLabel EtiquetaAcercade12=
JLabel EtiquetaAcercade13=
JLabel EtiquetaAcercade14=
JLabel EtiquetaAcercade15=
JLabel EtiquetaAcercade16=
JLabel EtiquetaAcercade17=
JLabel EtiquetaAcercade18=
JLabel EtiquetaAcercade19=
new
new
new
new
new
new
new
new
JLabel("
", JLabel.CENTER);
JLabel("UNIVERSIDAD NACIONAL ABIERTA", JLabel.CENTER);
JLabel("CENTRO LOCAL SUCRE - 17", JLabel.CENTER);
JLabel("INGENIERÍA DE SISTEMAS - 236", JLabel.CENTER);
JLabel("
", JLabel.CENTER);
JLabel("TRABAJO DE GRADO - 319", JLabel.CENTER);
JLabel("LAPSO: 2006-2", JLabel.CENTER);
JLabel("IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES",
new JLabel("A TRAVÉS DE LA PROGRAMACIÓN ORIENTADA A ASPECTOS",
new JLabel("
", JLabel.CENTER);
new JLabel("CASO DE ESTUDIO: Aplicación que simula",
new JLabel("el registro de inscripciones regulares de",
new
new
new
new
new
new
new
new
JLabel("una universidad (UNSIR 1.0.1)", JLabel.CENTER);
JLabel("
", JLabel.CENTER);
JLabel("AUTOR: CARLOS CÓRDOVA", JLabel.CENTER);
JLabel("C.I.: 8.441.858", JLabel.CENTER);
JLabel("
", JLabel.CENTER);
JLabel("
", JLabel.CENTER);
JLabel("
", JLabel.CENTER);
JLabel("
", JLabel.CENTER);
JButton BotonAceptarAcercade = new JButton("Aceptar");
JPanel PanelCreditos = new JPanel(new GridLayout(17,1));
JPanel PanelBotones = new JPanel(new GridLayout(1,3,60,1));
JPanel PanelPrincipal = new JPanel(new BorderLayout());
//*** Constructor de la clase
public DialogoAcercade()
{
//*** Se define el título y tamaño de la ventana
super(new Frame(), "Acerca de...", true);
setBounds( 0, 0, 400, 345 );
PanelCreditos.add(EtiquetaAcercade0);
PanelCreditos.add(EtiquetaAcercade1);
PanelCreditos.add(EtiquetaAcercade2);
PanelCreditos.add(EtiquetaAcercade3);
PanelCreditos.add(EtiquetaAcercade4);
PanelCreditos.add(EtiquetaAcercade5);
PanelCreditos.add(EtiquetaAcercade6);
PanelCreditos.add(EtiquetaAcercade7);
PanelCreditos.add(EtiquetaAcercade8);
PanelCreditos.add(EtiquetaAcercade9);
PanelCreditos.add(EtiquetaAcercade10);
PanelCreditos.add(EtiquetaAcercade11);
PanelCreditos.add(EtiquetaAcercade12);
PanelCreditos.add(EtiquetaAcercade13);
PanelCreditos.add(EtiquetaAcercade14);
PanelCreditos.add(EtiquetaAcercade15);
PanelCreditos.add(EtiquetaAcercade16);
BotonAceptarAcercade.setMnemonic('A');
BotonAceptarAcercade.setToolTipText("Salir...");
PanelBotones.add(EtiquetaAcercade17);
PanelBotones.add(BotonAceptarAcercade);
PanelBotones.add(EtiquetaAcercade18);
PanelPrincipal.add("North",PanelCreditos);
PanelPrincipal.add("Center",PanelBotones);
PanelPrincipal.add("South",EtiquetaAcercade19);
//*** Se agrega el panel principal al diálogo
getContentPane().add(PanelPrincipal);
//*** Para no cambiar el tamaño de la ventana
setResizable(false);
//*** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
//*** Eventos de los botones
BotonAceptarAcercade.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
dispose();
}
});
}
//*** Fin del constructor DialogoAcercade
}
//*** Fin de la clase DialogoAcercade
}
//***************************************************************************
// Fin Clase MenuAdministrador
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: MenuEstudiante (Para crear el menú del
****
//**** nivel estudiante con sólo las opciones de inscripción)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import
import
import
import
import
java.awt.*;
java.awt.event.*;
javax.swing.*;
java.util.Date;
java.awt.Color;
//***************************************************************************
// Inicio Clase MenuEstudiante
//***************************************************************************
public class MenuEstudiante extends JFrame implements ActionListener
{
//*** Se declaran las variables
String
String
String
String
DiaS = "";
Dia = "";
Mes = "";
Ano = "";
String esUsuario = "";
String esNombre = "";
int esCedula = 0;
static String adsCedula = "";
static String adsCedula2 = "";
static String adsCedula3 = "";
static String adsCedula4 = "";
String fechaTotal = String.valueOf(new Date());
static boolean nIMEU = false;
static boolean nMEU = false;
static
static
static
static
static
boolean
boolean
boolean
boolean
boolean
nControl3 = true;
nControl4 = true;
nControl6 = true;
nControl9 = true;
nControl11 = true;
static String Lapso;
//*** Se crean los componentes necesarios
ImageIcon imagen = new ImageIcon("C:/TG-319/4-IMAGENES/FondoUN.jpg");
JLabel EtiquetaMenu = new JLabel(imagen);
JMenuBar Barra = new JMenuBar();
JMenu Archivo = new JMenu("Archivo");
JMenuItem Salir = new JMenuItem("Salir");
JMenu Consultas = new JMenu("Consultas");
JMenuItem DatosPersonales = new JMenuItem("Datos personales...");
JMenuItem Historico = new JMenuItem("Histórico...");
JMenu Inscripcion = new JMenu("Inscripción");
JMenuItem SeleccionarAsignaturas = new JMenuItem("Seleccionar asignaturas...");
JMenuItem RegistrarInscripción = new JMenuItem("Registrar inscripción...");
JMenu Ayuda = new JMenu("Ayuda");
JMenuItem AyudaGeneral = new JMenuItem("Ayuda general...");
JMenuItem Acercade = new JMenuItem("Acerca de...");
JLabel
JLabel
JLabel
JLabel
EtiquetaUsuario = new JLabel();
EtiquetaNombre = new JLabel();
EtiquetaCI = new JLabel();
EtiquetaFecha = new JLabel();
//*** Se define el método principal "main" de la Clase MenuEstudiante
public static void main(String[] args)
{
//*** Se ejecuta el constructor MenuEstudiante de la clase MenuEstudiante
new MenuEstudiante();
}
//*** Inicio del constructor MenuEstudiante
public MenuEstudiante()
{
//*** Se define el título y tamaño de la ventana
setTitle("Universidad Nacional: Sistema de Inscripción Regular");
setBounds( 0, 0, 800, 600 );
setResizable(false);
//*** Se cambia el icono de la ventana
setIconImage (new ImageIcon("C:/TG-319/4-IMAGENES/UN.gif").getImage());
//*** Para ejecutar archivos desde java
final Runtime obj = Runtime.getRuntime();
//*** Barra de menú y opciones del menú
setJMenuBar(Barra);
Barra.add(Archivo);
Archivo.add(Salir);
Barra.add(Consultas);
Consultas.add(DatosPersonales);
Consultas.add(Historico);
Barra.add(Inscripcion);
Inscripcion.add(SeleccionarAsignaturas);
Inscripcion.add(RegistrarInscripción);
Barra.add(Ayuda);
Ayuda.add(AyudaGeneral);
Ayuda.add(Acercade);
//*** Se asignan las teclas calientes a las opciones del menú
Archivo.setMnemonic('A');
Salir.setMnemonic('S');
Consultas.setMnemonic('C');
DatosPersonales.setMnemonic('D');
Historico.setMnemonic('H');
Inscripcion.setMnemonic('I');
SeleccionarAsignaturas.setMnemonic('S');
RegistrarInscripción.setMnemonic('R');
Ayuda.setMnemonic('u');
AyudaGeneral.setMnemonic('A');
Acercade.setMnemonic('c');
Salir.setToolTipText("Salir de la aplicación");
DatosPersonales.setToolTipText("Muestra los datos personales del estudiante");
Historico.setToolTipText("Muestra el histórico de calificaciones del estudiante");
SeleccionarAsignaturas.setToolTipText("Oferta de asignaturas para seleccionar");
RegistrarInscripción.setToolTipText("Registrar comprobante de pago para la inscripción");
AyudaGeneral.setToolTipText("Muestra la ayuda general");
Acercade.setToolTipText("Muestra el diálogo acerca de...");
//*** Etiquetas y cajas de texto en el menú principal
EtiquetaMenu.add(EtiquetaUsuario);
EtiquetaUsuario.setBounds(20, 10, 215, 20);
EtiquetaUsuario.setFont(new Font("SansSerif", Font.BOLD, 16));
EtiquetaUsuario.setForeground( Color.RED);
EtiquetaUsuario.setBackground( Color.WHITE);
EtiquetaMenu.add(EtiquetaNombre);
EtiquetaNombre.setBounds(20, 50, 500, 30);
EtiquetaNombre.setFont(new Font("SansSerif", Font.BOLD, 20));
EtiquetaNombre.setForeground( Color.BLUE);
EtiquetaNombre.setBackground( Color.WHITE);
EtiquetaMenu.add(EtiquetaCI);
EtiquetaCI.setBounds(20, 80, 215, 20);
EtiquetaCI.setFont(new Font("SansSerif", Font.BOLD, 12));
EtiquetaCI.setForeground( Color.BLUE);
EtiquetaCI.setBackground( Color.WHITE);
IniciarEtiquetas(esUsuario,esNombre,esCedula);
//*** Para mostrar la fecha en la ventana del menú
DiaS = fechaTotal.substring(0,3);
Mes = fechaTotal.substring(4,7);
Dia = fechaTotal.substring(8,10);
Ano= fechaTotal.substring(fechaTotal.length() - 4, fechaTotal.length());
//*** Se muestran los días en español
if (DiaS.equals("Sun"))
DiaS = " Domingo";
if (DiaS.equals("Mon"))
DiaS = " Lunes";
if (DiaS.equals("Tue"))
DiaS = " Martes";
if (DiaS.equals("Wed"))
DiaS = " Miércoles";
if (DiaS.equals("Thu"))
DiaS = " Jueves";
if (DiaS.equals("Fri"))
DiaS = " Viernes";
if (DiaS.equals("Sat"))
DiaS = " Sábado";
//*** Se muestran los meses en español
if (Mes.equals("Jan"))
Mes = "Enero";
if (Mes.equals("Feb"))
Mes = "Febrero";
if (Mes.equals("Mar"))
Mes = "Marzo";
if (Mes.equals("Apr"))
Mes = "Abril";
if (Mes.equals("May"))
Mes = "Mayo";
if (Mes.equals("Jun"))
Mes = "Junio";
if (Mes.equals("Jul"))
Mes = "Julio";
if (Mes.equals("Aug"))
Mes = "Agosto";
if (Mes.equals("Sep"))
Mes = "Septiembre";
if (Mes.equals("Oct"))
Mes = "Octubre";
if (Mes.equals("Nov"))
Mes = "Noviembre";
if (Mes.equals("Dec"))
Mes = "Diciembre";
EtiquetaFecha.setText(DiaS + ", " + Dia + " de " + Mes + " de " + Ano);
EtiquetaMenu.add(EtiquetaFecha);
EtiquetaFecha.setBounds(560, 10, 215, 20); //*** (X, Y, Ancho, Alto)
EtiquetaFecha.setFont(new Font("SansSerif", Font.BOLD, 12));
EtiquetaFecha.setForeground( Color.BLUE);
EtiquetaFecha.setBackground( Color.WHITE);
if (Mes.equals("Jan") || Mes.equals("Feb") || Mes.equals("Mar") || Mes.equals("Apr") ||
Mes.equals("May") || Mes.equals("Jun"))
Lapso = Ano + "-1";
else
Lapso = Ano + "-2";
//*** Se agrega la imagen central en la ventana del menú
add(EtiquetaMenu);
//*** Se centra la ventana del menú en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2),
(pantalla.height - cuadro.height)/2);
//*** Se muestra el menú
setVisible( true );
//*** Eventos producidos por las opciones del menú
addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
Salir.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
DatosPersonales.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
ControlEstudiantes.nControl5 = true;
//*** Se crea una instancia de la clase ControlEstudiantes
ControlEstudiantes IntEstudiantes = new ControlEstudiantes();
///*******************************
///*** VITAL
****
///*******************************
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
nControl3 = false;
nControl4 = true;
nControl6 = false;
nControl9 = false;
nControl11 = false;
adsCedula = String.valueOf(ControlPassword.nCedula);
if (adsCedula.equals("0"))
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Se requiere de un usuario y contraseña para consultar los datos !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
else if (IntEstudiantes.BuscarCedula(adsCedula) == true)
{
MenuAdministrador.adsCedula = MenuEstudiante.adsCedula;
MenuEstudiante.adsCedula = "";
nIMEU = true;
Estudiantes d = new Estudiantes();
d.setTitle("Consultar datos personales");
d.CajaTextoCedula.setEditable(false);
d.CajaTextoNombreEstudiante.setEditable(false);
d.CajaTextoDireccion.setEditable(false);
d.CajaTextoTelefono.setEditable(false);
d.CajaTextoCorreo.setEditable(false);
d.ComboCarrera.setEnabled(true);
d.BotonCancelarEstudiante.setText("
Aceptar
");
d.BotonCancelarEstudiante.setMnemonic('A');
d.BotonCancelarEstudiante.setToolTipText("Salir de la consulta...");
d.BotonAceptarEstudiante.setVisible(false);
d.setVisible(true);
}
else
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ No existen datos personales para este usuario !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
}
});
Historico.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase ControlHistorico
ControlHistorico IntHistorico = new ControlHistorico();
///*******************************
///*** VITAL
****
///*******************************
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
nControl3 = false;
nControl4 = false;
nControl6 = true;
nControl9 = false;
nControl11 = false;
adsCedula = String.valueOf(ControlPassword.nCedula);
if (adsCedula.equals("0"))
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Se requiere de un usuario y contraseña para consultar los datos !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
else if (IntHistorico.BuscarCedula(adsCedula) == true)
{
MenuAdministrador.adsCedula2 = adsCedula;
adsCedula = "";
nIMEU = true;
Historico d = new Historico();
d.setVisible(true);
}
else
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ No existen datos del histórico para este usuario !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
}
});
SeleccionarAsignaturas.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase ControlInscripciones y ControlValidaciones
ControlInscripciones IntInscripciones = new ControlInscripciones();
ControlValidaciones IntValidaciones = new ControlValidaciones();
///*******************************
///*** VITAL
****
///*******************************
ControlValidaciones.nControl12 = false;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
nControl3 = false;
nControl4 = false;
nControl6 = false;
nControl9 = false;
nControl11 = true;
adsCedula = String.valueOf(ControlPassword.nCedula);
if (adsCedula.equals("0"))
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Se requiere de un usuario y contraseña para seleccionar asignaturas !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
else if (IntValidaciones.BuscarRegistro(adsCedula,Lapso) == true &&
IntValidaciones.BuscarCedula(adsCedula) == true)
{
MenuAdministrador.nMEU = true;
MenuAdministrador.adsCedula4 = adsCedula;
adsCedula = "";
nIMEU = true;
Validaciones d = new Validaciones();
d.setTitle("Registro de inscripción");
d.CajaTextoNumDeposito.setEditable(false);
d.CajaTextoMonDeposito.setEditable(false);
d.EtiquetaValidar.setText("
");
d.CheckValidar.setVisible(false);
d.BotonGuardarRegistro.setVisible(false);
d.BotonEliminarRegistro.setVisible(false);
d.setVisible(true);
}
else
{
///*******************************
///*** VITAL
****
///*******************************
ControlInscripciones.nControl10 = true;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlValidaciones.nControl12 = false;
nControl3 = false;
nControl4 = false;
nControl6 = false;
nControl9 = true;
nControl11 = false;
MenuAdministrador.nMEU = true;
MenuAdministrador.adsCedula3 = adsCedula;
adsCedula = "";
nIMEU = true;
if (!MenuAdministrador.adsCedula3.equals("") &&
IntInscripciones.BuscarCedula(MenuAdministrador.adsCedula3) == true)
{
Inscripciones d = new Inscripciones();
d.setVisible(true);
}
else
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ No existen datos de inscripción para este usuario !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlInscripciones.nControl10 = false;
nIMEU = false;
}
}
}
});
RegistrarInscripción.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase ControlValidaciones
ControlValidaciones IntValidaciones = new ControlValidaciones();
///*******************************
///*** VITAL
****
///*******************************
ControlValidaciones.nControl12 = true;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
nControl3 = false;
nControl4 = false;
nControl6 = false;
nControl9 = false;
nControl11 = true;
adsCedula = String.valueOf(ControlPassword.nCedula);
if (adsCedula.equals("0"))
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Se requiere de un usuario y contraseña para registrar la inscripción !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
else if (IntValidaciones.BuscarRegistro(adsCedula,Lapso) == true &&
IntValidaciones.BuscarCedula(adsCedula) == true)
{
MenuAdministrador.nMEU = true;
MenuAdministrador.adsCedula4 = adsCedula;
adsCedula = "";
nIMEU = true;
Validaciones d = new Validaciones();
d.setTitle("Registro de inscripción");
d.CajaTextoNumDeposito.setEditable(false);
d.CajaTextoMonDeposito.setEditable(false);
d.EtiquetaValidar.setText("
");
d.CheckValidar.setVisible(false);
d.BotonGuardarRegistro.setVisible(false);
d.BotonEliminarRegistro.setVisible(false);
d.setVisible(true);
}
else if (IntValidaciones.BuscarRegistro(adsCedula,Lapso) == false &&
IntValidaciones.BuscarCedula(adsCedula) == true)
{
MenuAdministrador.nMEU = true;
MenuAdministrador.adsCedula4 = adsCedula;
adsCedula = "";
nIMEU = true;
Validaciones d = new Validaciones();
d.setTitle("Registro de inscripción");
d.EtiquetaValidar.setText("
");
d.CheckValidar.setVisible(false);
d.BotonEliminarRegistro.setVisible(false);
d.BotonImprimirRegistro.setVisible(false);
if (d.MiTabla1.getRowCount() == 0 && !d.CajaTextoVNombre.getText().equals(""))
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ No tiene selección de asignaturas !!","Atención",
JOptionPane.WARNING_MESSAGE);
d.CierraVentana();
}
else
d.setVisible(true);
}
else
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ No existen datos de inscripción para este usuario !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlInscripciones.nControl10 = false;
nIMEU = false;
}
}
});
AyudaGeneral.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Ejecuta el archivo de ayuda UNSIR101.HLP
try
{
obj.exec("winhlp32.exe C:/TG-319/5-AYUDA/UNSIR101.HLP");
}
catch (Exception e)
{
System.out.println("Se ha producido un error: "+ e.toString());
}
}
});
Acercade.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoAcercade
DialogoAcercade d = new DialogoAcercade();
d.setVisible(true);
}
});
}
//*** Fin del constructor MenuEstudiante
//*** Se definen los métodos necesarios para abrir y cerrar el menú
public void actionPerformed(ActionEvent e)
{
Object s = e.getSource();
}
public void CierraVentana()
{
setVisible( false );
dispose();
System.exit(0);
}
//*** Se define el método IniciaEtiquetas para mostrar el nombre del usuario y cédula
public void IniciarEtiquetas(String mnuUsuario,String mnuNombre,int mnuCedula)
{
if(mnuUsuario.equals(""))
EtiquetaUsuario.setText("");
else
EtiquetaUsuario.setText("Usuario : " + mnuUsuario);
EtiquetaNombre.setText(mnuNombre);
if(mnuCedula == 0)
EtiquetaCI.setText("");
else
EtiquetaCI.setText("C.I.: " + mnuCedula);
}
//*** Se crea una nueva clase para crear un diáologo que sirve para mostrar
//*** los créditos del sistema
class DialogoAcercade extends JDialog
{
//*** Se crean los componentes necesarios
JLabel EtiquetaAcercade0 =
JLabel EtiquetaAcercade1 =
JLabel EtiquetaAcercade2 =
JLabel EtiquetaAcercade3 =
JLabel EtiquetaAcercade4 =
JLabel EtiquetaAcercade5 =
JLabel EtiquetaAcercade6 =
JLabel EtiquetaAcercade7 =
JLabel.CENTER);
JLabel EtiquetaAcercade8 =
JLabel.CENTER);
JLabel EtiquetaAcercade9 =
JLabel EtiquetaAcercade10=
JLabel.CENTER);
JLabel EtiquetaAcercade11=
JLabel.CENTER);
JLabel EtiquetaAcercade12=
JLabel EtiquetaAcercade13=
JLabel EtiquetaAcercade14=
JLabel EtiquetaAcercade15=
JLabel EtiquetaAcercade16=
JLabel EtiquetaAcercade17=
JLabel EtiquetaAcercade18=
JLabel EtiquetaAcercade19=
new
new
new
new
new
new
new
new
JLabel("
", JLabel.CENTER);
JLabel("UNIVERSIDAD NACIONAL ABIERTA", JLabel.CENTER);
JLabel("CENTRO LOCAL SUCRE - 17", JLabel.CENTER);
JLabel("INGENIERÍA DE SISTEMAS - 236", JLabel.CENTER);
JLabel("
", JLabel.CENTER);
JLabel("TRABAJO DE GRADO - 319", JLabel.CENTER);
JLabel("LAPSO: 2006-2", JLabel.CENTER);
JLabel("IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES",
new JLabel("A TRAVÉS DE LA PROGRAMACIÓN ORIENTADA A ASPECTOS",
new JLabel("
", JLabel.CENTER);
new JLabel("CASO DE ESTUDIO: Aplicación que simula",
new JLabel("el registro de inscripciones regulares de",
new
new
new
new
new
new
new
new
JLabel("una universidad (UNSIR 1.0.1)", JLabel.CENTER);
JLabel("
", JLabel.CENTER);
JLabel("AUTOR: CARLOS CÓRDOVA", JLabel.CENTER);
JLabel("C.I.: 8.441.858", JLabel.CENTER);
JLabel("
", JLabel.CENTER);
JLabel("
", JLabel.CENTER);
JLabel("
", JLabel.CENTER);
JLabel("
", JLabel.CENTER);
JButton BotonAceptarAcercade = new JButton("Aceptar");
JPanel PanelCreditos = new JPanel(new GridLayout(17,1));
JPanel PanelBotones = new JPanel(new GridLayout(1,3,60,1));
JPanel PanelPrincipal = new JPanel(new BorderLayout());
//*** Constructor de la clase
public DialogoAcercade()
{
//*** Se define el título y tamaño de la ventana
super(new Frame(), "Acerca de...", true);
setBounds( 0, 0, 400, 345 );
PanelCreditos.add(EtiquetaAcercade0);
PanelCreditos.add(EtiquetaAcercade1);
PanelCreditos.add(EtiquetaAcercade2);
PanelCreditos.add(EtiquetaAcercade3);
PanelCreditos.add(EtiquetaAcercade4);
PanelCreditos.add(EtiquetaAcercade5);
PanelCreditos.add(EtiquetaAcercade6);
PanelCreditos.add(EtiquetaAcercade7);
PanelCreditos.add(EtiquetaAcercade8);
PanelCreditos.add(EtiquetaAcercade9);
PanelCreditos.add(EtiquetaAcercade10);
PanelCreditos.add(EtiquetaAcercade11);
PanelCreditos.add(EtiquetaAcercade12);
PanelCreditos.add(EtiquetaAcercade13);
PanelCreditos.add(EtiquetaAcercade14);
PanelCreditos.add(EtiquetaAcercade15);
PanelCreditos.add(EtiquetaAcercade16);
BotonAceptarAcercade.setMnemonic('A');
BotonAceptarAcercade.setToolTipText("Salir...");
PanelBotones.add(EtiquetaAcercade17);
PanelBotones.add(BotonAceptarAcercade);
PanelBotones.add(EtiquetaAcercade18);
PanelPrincipal.add("North",PanelCreditos);
PanelPrincipal.add("Center",PanelBotones);
PanelPrincipal.add("South",EtiquetaAcercade19);
//*** Se agrega el panel principal al diálogo
getContentPane().add(PanelPrincipal);
//*** Para no cambiar el tamaño de la ventana
setResizable(false);
//*** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
//*** Eventos de los botones
BotonAceptarAcercade.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
dispose();
}
});
}
//*** Fin del constructor DialogoAcercade
}
//*** Fin de la clase DialogoAcercade
}
//***************************************************************************
// Fin Clase MenuEstudiante
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: Asignaturas (Crea un diálogo que sirve para ****
//**** ingresar datos de las asignaturas)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import
import
import
import
import
import
import
java.io.*;
java.sql.*;
java.awt.*;
java.awt.event.*;
javax.swing.*;
javax.swing.table.DefaultTableModel;
javax.swing.table.TableColumn;
//***************************************************************************
// Inicio Clase Asignaturas
//***************************************************************************
public class Asignaturas extends JDialog
{
//*** Se declaran las variables
static boolean nAsig = false;
static
static
static
static
static
static
String AsigCodigo;
String AsigNombre;
int AsigCreditos;
String AsigCodH;
String AsigNomH;
String AsigCreH;
static boolean nIngresa = true;
static String nTituloAsignatura = "Registrar asignatura";
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se crea una instancia IntAsignatura de la clase ControlAsignaturas para
//*** utilizar los métodos de esta clase y hacer las transacciones con la
//*** tabla ASIGNATURAS de la base de datos
ControlAsignaturas IntAsignatura = new ControlAsignaturas();
static
static
static
static
static
DefaultTableModel MiTabla = new DefaultTableModel();
JTable Tabla = new JTable(MiTabla);
JScrollPane scrollPane = new JScrollPane(Tabla);
Object [] Fila = new Object[3];
TableColumn MiColumna = new TableColumn();
JLabel Etiqueta1 = new JLabel("
JLabel Etiqueta2 = new JLabel("
");
");
JButton BotonAsignaturaNueva = new JButton(" Registrar ");
JLabel Etiqueta9 = new JLabel("
");
JButton BotonCambiarAsignatura = new JButton(" Cambiar ");
JLabel Etiqueta10 = new JLabel("
");
JButton BotonEliminarAsignatura = new JButton(" Eliminar ");
JLabel Etiqueta11 = new JLabel("
");
JButton BotonCancelarAsignatura = new JButton(" Cancelar ");
//*** Se define el método principal "main" de la Clase Asignaturas
public static void main(String g[])
{
//*** Se ejecuta el constructor Asignaturas de la clase Asignaturas
Asignaturas p = new Asignaturas();
p.setVisible(true);
//*** Para cerrar la ventana
p.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
});
}
//*** Inicio del constructor Asignaturas
Asignaturas()
{
//*** Se define el título de la ventana
super(new Frame(), "Asignaturas", true);
//*** Se define el tamaño de la ventana para el diálogo
setBounds( 0, 0, 550, 324 );
//*** Se crean los páneles para acomodar los componentes
JPanel
JPanel
JPanel
JPanel
PanelEspacioArriba = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelTabla = new JPanel();
PanelBotones = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelPricipal = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelEspacioArriba.add(Etiqueta1);
while (MiTabla.getRowCount() > 0)
{
MiTabla.removeRow(0);
}
Tabla.setPreferredScrollableViewportSize(new Dimension(500,175));
MiTabla.addColumn("Código");
MiTabla.addColumn("Nombre asignatura");
MiTabla.addColumn("U.C.");
while (Tabla.getColumnCount() > 3)
{
MiColumna = Tabla.getColumnModel().getColumn(3);
Tabla.removeColumn(MiColumna);
}
//*** Se hace la conexión y se llena la tabla(listado) con los datos.
try
{
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM ASIGNATURAS ORDER BY CodigoAsignatura";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
Fila[0] = String.valueOf(rs.getInt("CodigoAsignatura"));
Fila[1] = rs.getString("NombreAsignatura");
Fila[2] = String.valueOf(rs.getInt("UCAsignatura"));
MiTabla.addRow(Fila);
}
rs.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
}
PanelTabla.add(scrollPane, BorderLayout.CENTER);
PanelBotones.add(BotonAsignaturaNueva);
PanelBotones.add(Etiqueta9);
PanelBotones.add(BotonCambiarAsignatura);
PanelBotones.add(Etiqueta10);
PanelBotones.add(BotonEliminarAsignatura);
PanelBotones.add(Etiqueta11);
PanelBotones.add(BotonCancelarAsignatura);
BotonAsignaturaNueva.setMnemonic('R');
BotonAsignaturaNueva.setToolTipText("Registrar asignatura...");
BotonCambiarAsignatura.setMnemonic('m');
BotonCambiarAsignatura.setToolTipText("Cambiar asignatura...");
BotonEliminarAsignatura.setMnemonic('E');
BotonEliminarAsignatura.setToolTipText("Eliminar asignatura...");
BotonCancelarAsignatura.setMnemonic('C');
BotonCancelarAsignatura.setToolTipText("Cancelar y salir...");
// *** Se agrega el panel principal al diálogo
PanelPricipal.add(PanelEspacioArriba);
PanelPricipal.add(PanelTabla);
PanelPricipal.add(PanelBotones);
getContentPane().add(PanelPricipal);
//*** Se desactiva maximizar/minimizar
setResizable(false);
// *** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
//*** Eventos producidos por los botones del diálogo
this.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
BotonAsignaturaNueva.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoAsignatura
nIngresa = true;
nTituloAsignatura = "Registrar asignatura";
DialogoAsignatura d = new DialogoAsignatura();
d.setVisible(true);
}
});
BotonCambiarAsignatura.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoAsignatura
if (Tabla.getSelectedRow() == -1)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe seleccionar una asignatura de la tabla !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
else
{
AsigCodH = Tabla.getValueAt(Tabla.getSelectedRow(),0).toString();
AsigNomH = Tabla.getValueAt(Tabla.getSelectedRow(),1).toString();
AsigCreH = Tabla.getValueAt(Tabla.getSelectedRow(),2).toString();
nIngresa = false;
nTituloAsignatura = "Cambiar asignatura";
DialogoAsignatura d = new DialogoAsignatura();
d.setVisible(true);
}
}
});
BotonEliminarAsignatura.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
if (Tabla.getSelectedRow() == -1)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe seleccionar una asignatura de la tabla !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
else
{
Toolkit.getDefaultToolkit().beep();
int n = JOptionPane.showConfirmDialog(null,"¿ Quiere eliminar la asignatura seleccionada
?",
"Eliminar...",JOptionPane.YES_NO_OPTION);
if (n == JOptionPane.YES_OPTION)
{
//*** Se invoca el método EliminarDatos de la clase ControlAsignaturas
AsigCodH = Tabla.getValueAt(Tabla.getSelectedRow(),0).toString();
AsigNomH = Tabla.getValueAt(Tabla.getSelectedRow(),1).toString();
AsigCreH = Tabla.getValueAt(Tabla.getSelectedRow(),2).toString();
IntAsignatura.EliminarDatos(AsigCodH);
MiTabla.removeRow(Tabla.getSelectedRow());
}
}
}
});
BotonCancelarAsignatura.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
}
//*** Fin del constructor Asignaturas
//*** Se definen los métodos necesarios para abrir y cerrar el diálogo
public void actionPerformed(ActionEvent e)
{
Object s = e.getSource();
}
public void CierraVentana()
{
if (MenuAdministrador.nIMEU == true)
{
setVisible(false);
dispose();
}
else
{
setVisible( false );
dispose();
System.exit(0);
}
}
//*** Se crea una nueva clase para crear un diáologo que sirve para ingresar
//*** el código, nombre y número de créditos de la asignatura
class DialogoAsignatura extends JDialog
{
//*** Se crean los componentes necesarios
JLabel EtiquetaAsignatura = new JLabel("Código :");
JLabel Etiqueta1 = new JLabel("
");
JLabel Etiqueta2 = new JLabel("
");
TextField CajaTextoAsignatura = new TextField(5);
JLabel EtiquetaNombreAsignatura = new JLabel("Nombre :");
JLabel Etiqueta3 = new JLabel("
");
JLabel Etiqueta4 = new JLabel("");
TextField CajaTextoNombreAsignatura = new TextField(27);
JLabel EtiquetaCreditos = new JLabel("No.créditos :");
JLabel Etiqueta5 = new JLabel(" ");
JLabel Etiqueta6 = new JLabel("
String[] Creditos = {"1","2","3","4","5","6","7","8","9","10"};
JComboBox ComboCreditos = new JComboBox(Creditos);
JButton BotonAceptarAsig = new JButton("
JLabel Etiqueta9 = new JLabel("
");
JButton BotonCancelarAsig = new JButton("
Aceptar
");
Cancelar
");
public DialogoAsignatura()
{
//*** Se define el título y tamaño de la ventana
super(new Frame(), nTituloAsignatura, true);
setBounds( 0, 0, 345, 225 );
//*** Se crean los páneles para acomodar los componentes
JPanel
JPanel
JPanel
JPanel
PanelEspacioArriba = new JPanel();
PanelAsignatura = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelNomAsignatura = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelCreditos = new JPanel(new FlowLayout(FlowLayout.LEFT));
JPanel Panel1 = new JPanel(new BorderLayout(5,5));
JPanel Panel2 = new JPanel(new BorderLayout(5,5));
JPanel PanelBotones = new JPanel(new FlowLayout(FlowLayout.CENTER));
JPanel PanelPricipal = new JPanel(new FlowLayout(FlowLayout.CENTER));
//*** Se hace la conexión y se llena el ComboAsignatura con los
//*** datos de la tabla ASIGNATURA de la base de datos
if (Asignaturas.nIngresa == false)
{
CajaTextoAsignatura.setText(Asignaturas.AsigCodH);
CajaTextoAsignatura.setEditable(false);
CajaTextoNombreAsignatura.setText(Asignaturas.AsigNomH);
ComboCreditos.setSelectedItem(Asignaturas.AsigCreH);
}
else
CajaTextoAsignatura.setEditable(true);
ComboCreditos.setMaximumRowCount(3);
PanelAsignatura.add(EtiquetaAsignatura);
PanelAsignatura.add(Etiqueta1);
PanelAsignatura.add(CajaTextoAsignatura);
PanelAsignatura.add(Etiqueta2);
PanelNomAsignatura.add(EtiquetaNombreAsignatura);
PanelNomAsignatura.add(Etiqueta3);
PanelNomAsignatura.add(CajaTextoNombreAsignatura);
PanelCreditos.add(EtiquetaCreditos);
PanelCreditos.add(Etiqueta5);
PanelCreditos.add(ComboCreditos);
PanelCreditos.add(Etiqueta6);
Panel1.add(PanelEspacioArriba, BorderLayout.NORTH);
Panel1.add(PanelAsignatura, BorderLayout.CENTER);
Panel1.add(PanelNomAsignatura, BorderLayout.SOUTH);
Panel2.add(PanelCreditos, BorderLayout.NORTH);
BotonAceptarAsig.setMnemonic('A');
BotonAceptarAsig.setToolTipText("Guardar asignatura");
BotonCancelarAsig.setMnemonic('C');
BotonCancelarAsig.setToolTipText("Cancelar y salir");
PanelBotones.add(BotonAceptarAsig);
PanelBotones.add(Etiqueta9);
PanelBotones.add(BotonCancelarAsig);
PanelPricipal.add(Panel1);
PanelPricipal.add(Panel2);
PanelPricipal.add(PanelBotones);
getContentPane().add(PanelPricipal);
//*** Para no cambiar el tamaño de la ventana
");
setResizable(false);
//*** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
BotonAceptarAsig.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
///*******************************
///*** VITAL
****
///*******************************
IntAsignatura.nControl8 = true;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
MenuAdministrador.nControl3 = false;
MenuAdministrador.nControl4 = false;
MenuAdministrador.nControl6 = false;
MenuAdministrador.nControl9 = false;
MenuAdministrador.nControl11 = false;
AsigCodH = CajaTextoAsignatura.getText();
AsigNomH = CajaTextoNombreAsignatura.getText().toUpperCase();
AsigCreH = ComboCreditos.getSelectedItem().toString();
IntAsignatura.IniciarVariables();
IntAsignatura.VerificarDatos();
if (nAsig == true)
{
nAsig = false;
dispose();
}
}
});
BotonCancelarAsig.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
dispose();
}
});
}
//*** Fin del constructor DialogoAsignatura
}
//*** Fin de la clase DialogoAsignatura
}
//***************************************************************************
// Fin Clase Asignaturas
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: Pensum (Crea un diálogo que sirve para
****
//**** ingresar datos de los pensum de estudio)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import
import
import
import
import
import
import
java.io.*;
java.sql.*;
java.awt.*;
java.awt.event.*;
javax.swing.*;
javax.swing.table.DefaultTableModel;
javax.swing.table.TableColumn;
//***************************************************************************
// Inicio Clase Pensum
//***************************************************************************
public class Pensum extends JDialog
{
//*** Se declaran las variables
static boolean nPen = false;
static
static
static
static
static
static
static
String
String
String
String
String
String
String
PenCodCa;
PenCodAs;
PenSem;
PenPre1;
PenPre2;
PenPre3;
PenPre4;
static boolean nIngresa = true;
static String nTituloPensum = "Registrar pensum";
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se crea una instancia IntPensum de la clase ControlPensum para
//*** utilizar los métodos de esta clase y hacer las transacciones con la
//*** tabla PENSUM de la base de datos
ControlPensum IntPensum = new ControlPensum();
static
static
static
static
static
DefaultTableModel MiTabla = new DefaultTableModel();
JTable Tabla = new JTable(MiTabla);
JScrollPane scrollPane = new JScrollPane(Tabla);
Object [] Fila = new Object[9];
TableColumn MiColumna = new TableColumn();
JLabel Etiqueta1 = new JLabel("
JLabel Etiqueta2 = new JLabel("
JButton BotonPensumNueva = new JButton("
JLabel Etiqueta15 = new JLabel("
JButton BotonCambiarPensum = new JButton("
JLabel Etiqueta10 = new JLabel("
JButton BotonEliminarPensum = new JButton("
JLabel Etiqueta11 = new JLabel("
JButton BotonCancelarPensum = new JButton("
");
");
Registrar
");
Cambiar
");
Eliminar
");
Cancelar
//*** Se define el método principal "main" de la Clase Pensum
public static void main(String g[])
{
//*** Se ejecuta el constructor Pensum de la clase Pensum
Pensum p = new Pensum();
p.setVisible(true);
");
");
");
");
//*** Para cerrar la ventana
p.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
});
}
//*** Inicio del constructor Pensum
Pensum()
{
//*** Se define el título de la ventana
super(new Frame(), "Pensum por carrera", true);
//*** Se define el tamaño de la ventana para el diálogo
setBounds( 0, 0, 800, 500 );
//*** Se crean los páneles para acomodar los componentes
JPanel
JPanel
JPanel
JPanel
PanelEspacioArriba = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelTabla = new JPanel();
PanelBotones = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelPricipal = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelEspacioArriba.add(Etiqueta1);
while (MiTabla.getRowCount() > 0)
{
MiTabla.removeRow(0);
}
Tabla.setPreferredScrollableViewportSize(new Dimension(750,351));
MiTabla.addColumn("Código carrera");
MiTabla.addColumn("Código asignatura");
MiTabla.addColumn("Nombre asignatura");
MiTabla.addColumn("Semestre");
MiTabla.addColumn("U.C.");
MiTabla.addColumn("Pre-requisito 1");
MiTabla.addColumn("Pre-requisito 2");
MiTabla.addColumn("Pre-requisito 3");
MiTabla.addColumn("Pre-requisito 4");
while (Tabla.getColumnCount() > 9)
{
MiColumna = Tabla.getColumnModel().getColumn(9);
Tabla.removeColumn(MiColumna);
}
//*** Se hace la conexión y se llena la tabla(listado) con los datos.
try
{
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM ASIGNATURAS a, PENSUM b" +
" WHERE a.CodigoAsignatura = b.CodigoAsignatura" +
" ORDER BY b.CodigoCarrera,b.SemestreAsignatura,a.CodigoAsignatura";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
Fila[0] = String.valueOf(rs.getInt("CodigoCarrera"));
Fila[1] = String.valueOf(rs.getInt("CodigoAsignatura"));
Fila[2] = rs.getString("NombreAsignatura");
Fila[3] = String.valueOf(rs.getInt("SemestreAsignatura"));
Fila[4] = String.valueOf(rs.getInt("UCAsignatura"));
Fila[5] = String.valueOf(rs.getInt("CodigoPreRequisito1"));
Fila[6] = String.valueOf(rs.getInt("CodigoPreRequisito2"));
Fila[7] = String.valueOf(rs.getInt("CodigoPreRequisito3"));
Fila[8] = String.valueOf(rs.getInt("CodigoPreRequisito4"));
MiTabla.addRow(Fila);
}
rs.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
}
PanelTabla.add(scrollPane, BorderLayout.CENTER);
PanelBotones.add(BotonPensumNueva);
PanelBotones.add(Etiqueta15);
PanelBotones.add(BotonCambiarPensum);
PanelBotones.add(Etiqueta10);
PanelBotones.add(BotonEliminarPensum);
PanelBotones.add(Etiqueta11);
PanelBotones.add(BotonCancelarPensum);
BotonPensumNueva.setMnemonic('R');
BotonPensumNueva.setToolTipText("Registrar asignatura a pensum...");
BotonCambiarPensum.setMnemonic('m');
BotonCambiarPensum.setToolTipText("Cambiar asignatura de pensum...");
BotonEliminarPensum.setMnemonic('E');
BotonEliminarPensum.setToolTipText("Eliminar asignatura de pensum...");
BotonCancelarPensum.setMnemonic('C');
BotonCancelarPensum.setToolTipText("Cancelar y salir...");
// *** Se agrega el panel principal al diálogo
PanelPricipal.add(PanelEspacioArriba);
PanelPricipal.add(PanelTabla);
PanelPricipal.add(PanelBotones);
getContentPane().add(PanelPricipal);
//*** Se desactiva maximizar/minimizar
setResizable(false);
// *** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
//*** Eventos producidos por los botones del diálogo
this.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
BotonPensumNueva.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoPensum
nIngresa = true;
nTituloPensum = "Registrar pensum";
DialogoPensum d = new DialogoPensum();
d.setVisible(true);
}
});
BotonCambiarPensum.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoPensum
if (Tabla.getSelectedRow() == -1)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe seleccionar una asignatura de la tabla !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
else
{
PenCodCa = Tabla.getValueAt(Tabla.getSelectedRow(),0).toString();
PenCodAs = Tabla.getValueAt(Tabla.getSelectedRow(),1).toString();
PenSem = Tabla.getValueAt(Tabla.getSelectedRow(),3).toString();
PenPre1 = Tabla.getValueAt(Tabla.getSelectedRow(),5).toString();
PenPre2 = Tabla.getValueAt(Tabla.getSelectedRow(),6).toString();
PenPre3 = Tabla.getValueAt(Tabla.getSelectedRow(),7).toString();
PenPre4 = Tabla.getValueAt(Tabla.getSelectedRow(),8).toString();
nIngresa = false;
nTituloPensum = "Cambiar pensum";
DialogoPensum d = new DialogoPensum();
d.setVisible(true);
}
}
});
BotonEliminarPensum.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
if (Tabla.getSelectedRow() == -1)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe seleccionar una asignatura de la tabla !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
else
{
Toolkit.getDefaultToolkit().beep();
int n = JOptionPane.showConfirmDialog(null,"¿ Quiere eliminar la asignatura seleccionada
?",
"Eliminar...",JOptionPane.YES_NO_OPTION);
if (n == JOptionPane.YES_OPTION)
{
//*** Se invoca el método EliminarDatos de la clase ControlPensum
PenCodCa = Tabla.getValueAt(Tabla.getSelectedRow(),0).toString();
PenCodAs = Tabla.getValueAt(Tabla.getSelectedRow(),1).toString();
IntPensum.EliminarDatos(PenCodCa,PenCodAs);
MiTabla.removeRow(Tabla.getSelectedRow());
}
}
}
});
BotonCancelarPensum.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
}
//*** Fin del constructor Pensum
//*** Se definen los métodos necesarios para abrir y cerrar el diálogo
public void actionPerformed(ActionEvent e)
{
Object s = e.getSource();
}
public void CierraVentana()
{
if (MenuAdministrador.nIMEU == true)
{
setVisible(false);
dispose();
}
else
{
setVisible( false );
dispose();
System.exit(0);
}
}
//*** Se crea una nueva clase para crear un diáologo que sirve para ingresar
//*** el código, nombre y número de créditos de la pensum
class DialogoPensum extends JDialog
{
//*** Se crean los componentes necesarios
JLabel EtiquetaCarrera = new JLabel("Carrera :");
JLabel Etiqueta1 = new JLabel("
");
String[] Carrera = {"Ingeniería de Sistemas (236)", "Ingeniería Industrial (280)",
"Administración de Empresas (612)","Contaduría Pública (610)"};
JComboBox ComboCarrera = new JComboBox(Carrera);
JLabel EtiquetaAsignatura = new JLabel("Asignatura :");
JLabel Etiqueta3 = new JLabel(" ");
JLabel Etiqueta4 = new JLabel("
");
JComboBox ComboAsignatura = new JComboBox();
JLabel EtiquetaSemestre = new JLabel("Semestre :");
JLabel Etiqueta5 = new JLabel("
");
JLabel Etiqueta6 = new JLabel("
String[] Semestres = {"1","2","3","4","5","6","7","8","9","10"};
JComboBox ComboSemestre = new JComboBox(Semestres);
JLabel EtiquetaPR1
JLabel Etiqueta7 =
JLabel Etiqueta8 =
JComboBox ComboPR1
JCheckBox CheckPR1
");
= new JLabel("Pre-req 1 :");
new JLabel("
");
new JLabel("
");
= new JComboBox();
= new JCheckBox();
JLabel EtiquetaPR2 = new JLabel("Pre-req 2 :");
JLabel Etiqueta9 = new JLabel("
");
JLabel Etiqueta10 = new JLabel("
");
JComboBox ComboPR2 = new JComboBox();
JCheckBox CheckPR2 = new JCheckBox();
JLabel EtiquetaPR3 = new JLabel("Pre-req 3 :");
JLabel Etiqueta11 = new JLabel("
");
JLabel Etiqueta12 = new JLabel("
JComboBox ComboPR3 = new JComboBox();
JCheckBox CheckPR3 = new JCheckBox();
");
JLabel EtiquetaPR4 = new JLabel("Pre-req 4 :");
JLabel Etiqueta13 = new JLabel("
");
JLabel Etiqueta14 = new JLabel("
");
JComboBox ComboPR4 = new JComboBox();
JCheckBox CheckPR4 = new JCheckBox();
JButton BotonAceptarPen = new JButton("
Aceptar
JLabel Etiqueta15 = new JLabel("
");
JButton BotonCancelarPen = new JButton("
Cancelar
");
");
public DialogoPensum()
{
//*** Se define el título y tamaño de la ventana
super(new Frame(), nTituloPensum, true);
setBounds( 0, 0, 355, 378 );
//*** Se crean los páneles para acomodar los componentes
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
PanelEspacioArriba = new JPanel();
PanelCarrera = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelAsignatura = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelSemestres = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelPR1 = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelPR2 = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelPR3 = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelPR4 = new JPanel(new FlowLayout(FlowLayout.LEFT));
JPanel Panel1 = new JPanel(new BorderLayout(5,5));
JPanel Panel2 = new JPanel(new BorderLayout(5,5));
JPanel Panel3 = new JPanel(new BorderLayout(5,5));
JPanel PanelBotones = new JPanel(new FlowLayout(FlowLayout.CENTER));
JPanel PanelPricipal = new JPanel(new FlowLayout(FlowLayout.CENTER));
//*** Se hace la conexión y se llena el ComboAsignatura con los
//*** datos de la tabla ASIGNATURA
try
{
int i = 0;
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM ASIGNATURAS ORDER BY CodigoAsignatura";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
String asig = String.valueOf(rs.getInt("CodigoAsignatura"));
ComboAsignatura.addItem(asig);
ComboPR1.addItem(asig);
ComboPR2.addItem(asig);
ComboPR3.addItem(asig);
ComboPR4.addItem(asig);
i = i + 1;
}
rs.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
}
if (Pensum.nIngresa == false)
{
if (PenCodCa.equals("236"))
ComboCarrera.setSelectedIndex(0);
if (PenCodCa.equals("280"))
ComboCarrera.setSelectedIndex(1);
if (PenCodCa.equals("612"))
ComboCarrera.setSelectedIndex(2);
if (PenCodCa.equals("610"))
ComboCarrera.setSelectedIndex(3);
ComboAsignatura.setSelectedItem(Pensum.PenCodAs);
ComboSemestre.setSelectedItem(Pensum.PenSem);
ComboPR1.setSelectedItem(Pensum.PenPre1);
ComboPR2.setSelectedItem(Pensum.PenPre2);
ComboPR3.setSelectedItem(Pensum.PenPre3);
ComboPR4.setSelectedItem(Pensum.PenPre4);
if (!Pensum.PenPre1.equals("0"))
{
CheckPR1.setSelected(true);
ComboPR1.setEnabled(true);
}
else
{
CheckPR1.setSelected(false);
ComboPR1.setEnabled(false);
}
if (!Pensum.PenPre2.equals("0"))
{
CheckPR2.setSelected(true);
ComboPR2.setEnabled(true);
}
else
{
CheckPR2.setSelected(false);
ComboPR2.setEnabled(false);
}
if (!Pensum.PenPre3.equals("0"))
{
CheckPR3.setSelected(true);
ComboPR3.setEnabled(true);
}
else
{
CheckPR3.setSelected(false);
ComboPR3.setEnabled(false);
}
if (!Pensum.PenPre4.equals("0"))
{
CheckPR4.setSelected(true);
ComboPR4.setEnabled(true);
}
else
{
CheckPR4.setSelected(false);
ComboPR4.setEnabled(false);
}
}
else
{
CheckPR1.setSelected(false);
ComboPR1.setEnabled(false);
CheckPR2.setSelected(false);
ComboPR2.setEnabled(false);
CheckPR3.setSelected(false);
ComboPR3.setEnabled(false);
CheckPR4.setSelected(false);
ComboPR4.setEnabled(false);
}
ComboAsignatura.setMaximumRowCount(4);
ComboSemestre.setMaximumRowCount(3);
ComboPR1.setMaximumRowCount(3);
ComboPR2.setMaximumRowCount(3);
ComboPR3.setMaximumRowCount(3);
ComboPR4.setMaximumRowCount(3);
PanelCarrera.add(EtiquetaCarrera);
PanelCarrera.add(Etiqueta1);
PanelCarrera.add(ComboCarrera);
PanelAsignatura.add(EtiquetaAsignatura);
PanelAsignatura.add(Etiqueta3);
PanelAsignatura.add(ComboAsignatura);
PanelAsignatura.add(Etiqueta4);
PanelSemestres.add(EtiquetaSemestre);
PanelSemestres.add(Etiqueta5);
PanelSemestres.add(ComboSemestre);
PanelSemestres.add(Etiqueta6);
PanelPR1.add(EtiquetaPR1);
PanelPR1.add(Etiqueta7);
PanelPR1.add(ComboPR1);
PanelPR1.add(CheckPR1);
PanelPR1.add(Etiqueta8);
PanelPR2.add(EtiquetaPR2);
PanelPR2.add(Etiqueta9);
PanelPR2.add(ComboPR2);
PanelPR2.add(CheckPR2);
PanelPR2.add(Etiqueta10);
PanelPR3.add(EtiquetaPR3);
PanelPR3.add(Etiqueta11);
PanelPR3.add(ComboPR3);
PanelPR3.add(CheckPR3);
PanelPR3.add(Etiqueta12);
PanelPR4.add(EtiquetaPR4);
PanelPR4.add(Etiqueta13);
PanelPR4.add(ComboPR4);
PanelPR4.add(CheckPR4);
PanelPR4.add(Etiqueta14);
Panel1.add(PanelEspacioArriba, BorderLayout.NORTH);
Panel1.add(PanelCarrera, BorderLayout.CENTER);
Panel1.add(PanelAsignatura, BorderLayout.SOUTH);
Panel2.add(PanelSemestres, BorderLayout.NORTH);
Panel2.add(PanelPR1, BorderLayout.CENTER);
Panel2.add(PanelPR2, BorderLayout.SOUTH);
Panel3.add(PanelPR3, BorderLayout.NORTH);
Panel3.add(PanelPR4, BorderLayout.CENTER);
BotonAceptarPen.setMnemonic('A');
BotonAceptarPen.setToolTipText("Guardar pensum");
BotonCancelarPen.setMnemonic('C');
BotonCancelarPen.setToolTipText("Cancelar y salir");
PanelBotones.add(BotonAceptarPen);
PanelBotones.add(Etiqueta15);
PanelBotones.add(BotonCancelarPen);
PanelPricipal.add(Panel1);
PanelPricipal.add(Panel2);
PanelPricipal.add(Panel3);
PanelPricipal.add(PanelBotones);
getContentPane().add(PanelPricipal);
//*** Para no cambiar el tamaño de la ventana
setResizable(false);
//*** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
CheckPR1.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
boolean PR1 = true;
PR1 = CheckPR1.isSelected() ? true : false;
ComboPR1.setEnabled(PR1);
}
});
CheckPR2.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
boolean PR2 = false;
PR2 = CheckPR2.isSelected() ? true : false;
ComboPR2.setEnabled(PR2);
}
});
CheckPR3.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
boolean PR3 = false;
PR3 = CheckPR3.isSelected() ? true : false;
ComboPR3.setEnabled(PR3);
}
});
CheckPR4.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
boolean PR4 = false;
PR4 = CheckPR4.isSelected() ? true : false;
ComboPR4.setEnabled(PR4);
}
});
BotonAceptarPen.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
int car = ComboCarrera.getSelectedIndex();
if(car == 0)
PenCodCa = "236";
if(car == 1)
PenCodCa = "280";
if(car == 2)
PenCodCa = "612";
if(car == 3)
PenCodCa = "610";
PenCodAs = ComboAsignatura.getSelectedItem().toString();
PenSem = ComboSemestre.getSelectedItem().toString();
if(CheckPR1.isSelected() == true)
PenPre1 = ComboPR1.getSelectedItem().toString();
else
PenPre1 = "0";
if(CheckPR2.isSelected() == true)
PenPre2 = ComboPR2.getSelectedItem().toString();
else
PenPre2 = "0";
if(CheckPR3.isSelected() == true)
PenPre3 = ComboPR3.getSelectedItem().toString();
else
PenPre3 = "0";
if(CheckPR4.isSelected() == true)
PenPre4 = ComboPR4.getSelectedItem().toString();
else
PenPre4 = "0";
boolean nExisteAsig = false;
if (nIngresa == true)
{
for (int i=0; i<Pensum.MiTabla.getRowCount(); i++)
{
if(PenCodCa.equals(Pensum.MiTabla.getValueAt(i,0).toString()) &&
PenCodAs.equals(Pensum.MiTabla.getValueAt(i,1).toString()))
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ La asignatura " + PenCodAs + " ya existe para este pensum !!","Atención",
JOptionPane.WARNING_MESSAGE);
nExisteAsig = true;
break;
}
}
}
if (nExisteAsig == false)
{
IntPensum.IniciarVariables();
IntPensum.VerificarDatos();
if (nPen == true)
{
nPen = false;
dispose();
}
}
}
});
BotonCancelarPen.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
dispose();
}
});
}
//*** Fin del constructor DialogoPensum
}
//*** Fin de la clase DialogoPensum
}
//***************************************************************************
// Fin Clase Pensum
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: Estudiantes (Crea un diálogo que sirve para ****
//**** ingresar o mostrar los datos de los estudiantes)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
//***************************************************************************
// Inicio Clase Estudiantes
//***************************************************************************
public class Estudiantes extends JDialog
{
//*** Se declaran las variables
static
static
static
static
static
static
static
static
boolean nEst = false;
int EstDia;
int EstMes;
int EstAno;
int EstSex;
int EstCar;
int EstCen;
boolean nIngresa = true;
//*** Se crea una instancia IntEstudiantes de la clase ControlEstudiantes para
//*** utilizar los métodos de esta clase y hacer las transacciones con la
//*** tabla ESTUDIANTES de la base de datos
ControlEstudiantes IntEstudiantes = new ControlEstudiantes();
//*** Se crean los componentes necesarios
JLabel NumeroCedula = new JLabel("No. de cédula :");
JLabel Etiqueta1 = new JLabel("
");
static TextField CajaTextoCedula = new TextField(10);
JLabel EtiquetaNombreEstudiante = new JLabel("Nombre estudiante :");
JLabel Etiqueta2 = new JLabel(" ");
static TextField CajaTextoNombreEstudiante = new TextField(35);
JLabel
JLabel
JLabel
static
EtiquetaFechaNacimiento = new JLabel("Fecha nacimiento :");
Etiqueta3 = new JLabel("
");
Etiqueta4 = new JLabel("
");
String[] Dia = {"1","2","3","4","5","6","7","8","9","10","11","12","13","14","15",
"16","17","18","19","20","21","22","23","24","25","26","27","28",
"29","30","31" };
JComboBox ComboDia = new JComboBox(Dia);
static String[] Mes = {"1","2","3","4","5","6","7","8","9","10","11","12"};
JComboBox ComboMes = new JComboBox(Mes);
static String[] Ano = {"1955","1956","1957","1958","1959","1960","1961","1962","1963","1964",
"1965","1966","1967","1968","1969","1970","1971","1972","1973","1974",
"1975","1976","1977","1978","1979","1980","1981","1982","1983","1984",
"1985","1986","1987","1988","1989","1990","1991","1992","1993","1994",};
JComboBox ComboAno = new JComboBox(Ano);
JLabel EtiquetaSexo = new JLabel("Sexo :");
JLabel Etiqueta5 = new JLabel("
JLabel Etiqueta6 = new JLabel("
static String[] Sexo = {"Masculino","Femenino"};
JComboBox ComboSexo = new JComboBox(Sexo);
");
");
JLabel EtiquetaDireccion = new JLabel("Dirección :");
JLabel Etiqueta7 = new JLabel("
");
static TextField CajaTextoDireccion = new TextField(35);
JLabel
JLabel
JLabel
static
EtiquetaTelefono = new JLabel("Teléfono(s) :");
Etiqueta8 = new JLabel("
");
Etiqueta9 = new JLabel("
");
TextField CajaTextoTelefono = new TextField(25);
JLabel
JLabel
JLabel
static
EtiquetaCorreo = new JLabel("Correo (e-mail) :");
Etiqueta10 = new JLabel("
");
Etiqueta11 = new JLabel("
");
TextField CajaTextoCorreo = new TextField(25);
JLabel
JLabel
JLabel
static
EtiquetaCarrera = new JLabel("Carrera :");
Etiqueta12 = new JLabel("
");
Etiqueta13 = new JLabel("
");
String[] Carrera = {"Ingeniería de Sistemas (236)", "Ingeniería Industrial (280)",
"Administración de Empresas (612)","Contaduría Pública (610)"};
JComboBox ComboCarrera = new JComboBox(Carrera);
JLabel
JLabel
JLabel
static
EtiquetaCentro = new JLabel("Centro local :");
Etiqueta14 = new JLabel("
");
Etiqueta15 = new JLabel("
");
String[] Centro = {"Zona Central","Zona Occidental","Zona Oriental","Zona Sur"};
JComboBox ComboCentro = new JComboBox(Centro);
JButton BotonAceptarEstudiante = new JButton("
JLabel Etiqueta16 = new JLabel("
");
JButton BotonCancelarEstudiante = new JButton("
Aceptar
");
Cancelar
");
//*** Se define el método principal "main" de la Clase Estudiantes
public static void main(String g[])
{
//*** Se ejecuta el constructor Estudiantes de la clase Estudiantes
Estudiantes p = new Estudiantes();
p.setVisible(true);
//*** Para cerrar la ventana
p.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
});
}
//*** Inicio del constructor Estudiantes
Estudiantes()
{
//*** Se define el título de la ventana
super(new Frame(), "Registrar estudiante", true);
//*** Se define el tamaño de la ventana para el diálogo
setBounds( 0, 0, 450, 460 );
//*** Se crean los páneles para acomodar los componentes
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
PanelEspacioArriba = new JPanel();
PanelCedulaEstudiante = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelNombreEstudiante = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelFechaNacimiento = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelSexo = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelDireccion = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelTelefono = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelCorreo = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelCarrera = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelCentro = new JPanel(new FlowLayout(FlowLayout.LEFT));
JPanel
JPanel
JPanel
JPanel
Panel1
Panel2
Panel3
Panel4
=
=
=
=
new
new
new
new
JPanel(new
JPanel(new
JPanel(new
JPanel(new
BorderLayout(5,5));
BorderLayout(5,5));
BorderLayout(5,5));
BorderLayout(5,5));
JPanel PanelBotones = new JPanel(new FlowLayout(FlowLayout.CENTER));
JPanel PanelPricipal = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelCedulaEstudiante.add(NumeroCedula);
PanelCedulaEstudiante.add(Etiqueta1);
PanelCedulaEstudiante.add(CajaTextoCedula);
PanelNombreEstudiante.add(EtiquetaNombreEstudiante);
PanelNombreEstudiante.add(Etiqueta2);
PanelNombreEstudiante.add(CajaTextoNombreEstudiante);
PanelFechaNacimiento.add(EtiquetaFechaNacimiento);
PanelFechaNacimiento.add(Etiqueta3);
PanelFechaNacimiento.add(ComboDia);
PanelFechaNacimiento.add(ComboMes);
PanelFechaNacimiento.add(ComboAno);
PanelFechaNacimiento.add(Etiqueta4);
PanelSexo.add(EtiquetaSexo);
PanelSexo.add(Etiqueta5);
PanelSexo.add(ComboSexo);
PanelSexo.add(Etiqueta6);
PanelDireccion.add(EtiquetaDireccion);
PanelDireccion.add(Etiqueta7);
PanelDireccion.add(CajaTextoDireccion);
PanelTelefono.add(EtiquetaTelefono);
PanelTelefono.add(Etiqueta8);
PanelTelefono.add(CajaTextoTelefono);
PanelTelefono.add(Etiqueta9);
PanelCorreo.add(EtiquetaCorreo);
PanelCorreo.add(Etiqueta10);
PanelCorreo.add(CajaTextoCorreo);
PanelCorreo.add(Etiqueta11);
PanelCarrera.add(EtiquetaCarrera);
PanelCarrera.add(Etiqueta12);
PanelCarrera.add(ComboCarrera);
PanelCarrera.add(Etiqueta13);
PanelCentro.add(EtiquetaCentro);
PanelCentro.add(Etiqueta14);
PanelCentro.add(ComboCentro);
PanelCentro.add(Etiqueta15);
Panel1.add(PanelEspacioArriba, BorderLayout.NORTH);
Panel1.add(PanelCedulaEstudiante, BorderLayout.CENTER);
Panel1.add(PanelNombreEstudiante, BorderLayout.SOUTH);
Panel2.add(PanelDireccion, BorderLayout.NORTH);
Panel2.add(PanelTelefono, BorderLayout.CENTER);
Panel2.add(PanelCorreo, BorderLayout.SOUTH);
Panel3.add(PanelFechaNacimiento, BorderLayout.NORTH);
Panel3.add(PanelSexo, BorderLayout.CENTER);
Panel3.add(PanelCarrera, BorderLayout.SOUTH);
Panel4.add(PanelCentro, BorderLayout.NORTH);
PanelBotones.add(BotonAceptarEstudiante);
PanelBotones.add(Etiqueta16);
PanelBotones.add(BotonCancelarEstudiante);
ComboCentro.setMaximumRowCount(3);
CajaTextoCedula.setEditable(true);
CajaTextoNombreEstudiante.setEditable(true);
CajaTextoDireccion.setEditable(true);
CajaTextoTelefono.setEditable(true);
CajaTextoCorreo.setEditable(true);
ComboCarrera.setEnabled(true);
BotonAceptarEstudiante.setText("
Aceptar
");
BotonAceptarEstudiante.setMnemonic('A');
BotonAceptarEstudiante.setToolTipText("Registrar estudiante...");
if (MenuAdministrador.adsCedula.equals(""))
{
nIngresa = true;
CajaTextoCedula.setText("");
CajaTextoNombreEstudiante.setText("");
ComboDia.setSelectedIndex(0);
ComboMes.setSelectedIndex(0);
ComboAno.setSelectedIndex(0);
ComboSexo.setSelectedIndex(0);
CajaTextoDireccion.setText("");
CajaTextoTelefono.setText("");
CajaTextoCorreo.setText("");
ComboCarrera.setSelectedIndex(0);
ComboCentro.setSelectedIndex(0);
}
else
{
nIngresa = false;
if (IntEstudiantes.BuscarCedula(MenuAdministrador.adsCedula) == true)
{
if (MenuAdministrador.nMEU == false)
{
CajaTextoCedula.setEditable(false);
CajaTextoNombreEstudiante.setEditable(false);
CajaTextoDireccion.setEditable(false);
CajaTextoTelefono.setEditable(false);
CajaTextoCorreo.setEditable(false);
ComboCarrera.setEnabled(true);
BotonAceptarEstudiante.setText("
Eliminar
");
BotonAceptarEstudiante.setMnemonic('E');
BotonAceptarEstudiante.setToolTipText("Eliminar estudiante...");
}
else
ComboCarrera.setEnabled(false);
CajaTextoCedula.setText(MenuAdministrador.adsCedula);
CajaTextoCedula.setEditable(false);
CajaTextoNombreEstudiante.setText(IntEstudiantes.vNombre);
ComboDia.setSelectedIndex(IntEstudiantes.vDia);
ComboMes.setSelectedIndex(IntEstudiantes.vMes);
ComboAno.setSelectedIndex(IntEstudiantes.vAno);
ComboSexo.setSelectedIndex(IntEstudiantes.vSexo);
CajaTextoDireccion.setText(IntEstudiantes.vDireccion);
CajaTextoTelefono.setText(IntEstudiantes.vTelefono);
CajaTextoCorreo.setText(IntEstudiantes.vCorreo);
ComboCarrera.setSelectedIndex(IntEstudiantes.vCarrera);
ComboCentro.setSelectedIndex(IntEstudiantes.vCentro);
}
}
BotonCancelarEstudiante.setMnemonic('C');
BotonCancelarEstudiante.setToolTipText("Cancelar y salir...");
// *** Se agrega el panel principal al diálogo
PanelPricipal.add(Panel1);
PanelPricipal.add(Panel2);
PanelPricipal.add(Panel3);
PanelPricipal.add(Panel4);
PanelPricipal.add(PanelBotones);
getContentPane().add(PanelPricipal);
//*** Se desactiva maximizar/minimizar
setResizable(false);
// *** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
//*** Eventos producidos por los botones del diálogo
this.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
BotonAceptarEstudiante.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
///*******************************
///*** VITAL
****
///*******************************
IntEstudiantes.nControl5 = true;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
MenuAdministrador.nControl3 = false;
MenuAdministrador.nControl4 = false;
MenuAdministrador.nControl6 = false;
MenuAdministrador.nControl9 = false;
MenuAdministrador.nControl11 = false;
if (nIngresa == true)
{
//*** Se invocan los métodos IniciarVariables-VerificarDatos de la
//*** clase ControlEstudiantes
EstDia = ComboDia.getSelectedIndex();
EstMes = ComboMes.getSelectedIndex();
EstAno = ComboAno.getSelectedIndex();
EstSex = ComboSexo.getSelectedIndex();
EstCar = ComboCarrera.getSelectedIndex();
EstCen = ComboCentro.getSelectedIndex();
IntEstudiantes.IniciarVariables();
IntEstudiantes.VerificarDatos();
MenuAdministrador.adsCedula = "";
}
else
{
if (MenuAdministrador.nMEU == true)
{
//*** Se invocan los métodos IniciarVariables-VerificarDatos de la
//*** clase ControlEstudiantes
EstDia = ComboDia.getSelectedIndex();
EstMes = ComboMes.getSelectedIndex();
EstAno = ComboAno.getSelectedIndex();
EstSex = ComboSexo.getSelectedIndex();
EstCar = ComboCarrera.getSelectedIndex();
EstCen = ComboCentro.getSelectedIndex();
IntEstudiantes.IniciarVariables();
IntEstudiantes.VerificarDatos();
MenuAdministrador.adsCedula = "";
}
else
{
Toolkit.getDefaultToolkit().beep();
int n = JOptionPane.showConfirmDialog(null,"¿ Quiere eliminar este estudiante ?",
"Eliminar...",JOptionPane.YES_NO_OPTION);
if (n == JOptionPane.YES_OPTION)
{
//*** Se invoca el método EliminarDatos de la clase ControlUsuarios
IntEstudiantes.EliminarDatos(MenuAdministrador.adsCedula);
MenuAdministrador.adsCedula = "";
}
else
{
nEst = true;
MenuAdministrador.adsCedula = "";
}
}
}
MenuAdministrador.nTituloUsuario = "Registrar usuario y contraseña";
if (nEst == true)
{
nEst = false;
CierraVentana();
}
}
});
BotonCancelarEstudiante.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
MenuAdministrador.adsCedula = "";
setTitle("Registrar estudiantes");
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
}
//*** Fin del constructor Estudiantes
//*** Se definen los métodos necesarios para abrir y cerrar el diálogo
public void actionPerformed(ActionEvent e)
{
Object s = e.getSource();
}
public void CierraVentana()
{
if (MenuAdministrador.nIMEU == true || MenuEstudiante.nIMEU == true)
{
setVisible(false);
dispose();
}
else
{
setVisible( false );
dispose();
System.exit(0);
}
}
}
//***************************************************************************
// Fin Clase Estudiantes
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: Historico (Crea un diálogo que sirve para
****
//**** ingresar, cambiar, eliminar o mostrar las calificaciones del
****
//**** histórico de los estudiantes)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import
import
import
import
import
import
import
java.io.*;
java.sql.*;
java.awt.*;
java.awt.event.*;
javax.swing.*;
java.text.*;
javax.swing.table.DefaultTableModel;
import javax.swing.table.TableColumn;
//***************************************************************************
// Inicio Clase Historico
//***************************************************************************
public class Historico extends JDialog
{
//*** Se declaran las variables
static boolean nHis = false;
static
static
static
static
static
static
String HisCedula;
int HisCar;
int HisCen;
String HisAsiH;
String HisCalH;
String HisLapH;
static double HisIndice = 0;
static double HisTCreditos = 0;
static double HisUCXCAL = 0;
NumberFormat nf;
static boolean nIngresa = true;
static String nTituloHistorico = "Registrar calificación estudiante";
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se crea una instancia IntHistorico de la clase ControlHistorico para
//*** utilizar los métodos de esta clase y hacer las transacciones con la
//*** tabla HISTORICO de la base de datos
ControlHistorico IntHistorico = new ControlHistorico();
//*** Se crean los componentes necesarios
JLabel NumeroCedula = new JLabel("No. de cédula :");
JLabel Etiqueta1 = new JLabel("
");
static TextField CajaTextoCedula = new TextField(10);
JLabel EtiquetaNombreEstudiante = new JLabel("Nombre estudiante :");
JLabel Etiqueta2 = new JLabel(" ");
static TextField CajaTextoNombreEstudiante = new TextField(35);
JLabel
JLabel
JLabel
static
EtiquetaCarrera = new JLabel("Carrera :");
Etiqueta3 = new JLabel("
");
Etiqueta4 = new JLabel("
");
TextField CajaTextoCarrera = new TextField(25);
JLabel
JLabel
JLabel
static
EtiquetaCentroLocal = new JLabel("Centro Local :");
Etiqueta5 = new JLabel("
");
Etiqueta6 = new JLabel("
");
TextField CajaTextoCentro = new TextField(25);
JLabel
JLabel
JLabel
static
EtiquetaIndice = new JLabel("Índice académico :
Etiqueta7 = new JLabel("
Etiqueta8 = new JLabel("
TextField CajaTextoIndice = new TextField(10);
static
static
static
static
static
DefaultTableModel MiTabla = new DefaultTableModel();
JTable Tabla = new JTable(MiTabla);
JScrollPane scrollPane = new JScrollPane(Tabla);
Object [] Fila = new Object[6];
TableColumn MiColumna = new TableColumn();
JButton BotonCalificacionNueva = new JButton("
JLabel Etiqueta9 = new JLabel("
");
JButton BotonCambiarCalificacion = new JButton("
JLabel Etiqueta10 = new JLabel("
");
JButton BotonEliminarCalificacion = new JButton("
");
");
");
Registrar
");
Cambiar
");
Eliminar
");
JLabel Etiqueta11 = new JLabel("
");
JButton BotonCancelarCalificacion = new JButton("
Cancelar
");
//*** Se define el método principal "main" de la Clase Historico
public static void main(String g[])
{
//*** Se ejecuta el constructor Historico de la clase Historico
Historico p = new Historico();
p.setVisible(true);
//*** Para cerrar la ventana
p.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
});
}
//*** Inicio del constructor Historico
Historico()
{
//*** Se define el título de la ventana
super(new Frame(), "Histórico de calificaciones del estudiante", true);
//*** Se define el tamaño de la ventana para el diálogo
setBounds( 0, 0, 650, 460 );
//*** Se crean los páneles para acomodar los componentes
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
PanelEspacioArriba = new JPanel();
PanelCedulaHistorico = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelNombreHistorico = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelCarrera = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelCentroLocal = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelTabla = new JPanel();
JPanel
JPanel
JPanel
JPanel
Panel1
Panel2
Panel3
Panel4
=
=
=
=
new
new
new
new
JPanel(new
JPanel(new
JPanel(new
JPanel(new
BorderLayout(5,5));
BorderLayout(5,5));
BorderLayout(5,5));
BorderLayout(5,5));
JPanel PanelBotones = new JPanel(new FlowLayout(FlowLayout.CENTER));
JPanel PanelPricipal = new JPanel(new FlowLayout(FlowLayout.CENTER));
CajaTextoCedula.setEditable(false);
CajaTextoCedula.setText(MenuAdministrador.adsCedula2);
PanelCedulaHistorico.add(NumeroCedula);
PanelCedulaHistorico.add(Etiqueta1);
PanelCedulaHistorico.add(CajaTextoCedula);
CajaTextoNombreEstudiante.setEditable(false);
CajaTextoNombreEstudiante.setText(IntHistorico.vNombre);
PanelNombreHistorico.add(EtiquetaNombreEstudiante);
PanelNombreHistorico.add(Etiqueta2);
PanelNombreHistorico.add(CajaTextoNombreEstudiante);
CajaTextoCarrera.setEditable(false);
CajaTextoCarrera.setText(IntHistorico.CarreraH);
PanelCarrera.add(EtiquetaCarrera);
PanelCarrera.add(Etiqueta3);
PanelCarrera.add(CajaTextoCarrera);
PanelCarrera.add(Etiqueta4);
CajaTextoCentro.setEditable(false);
CajaTextoCentro.setText(IntHistorico.CentroH);
PanelCentroLocal.add(EtiquetaCentroLocal);
PanelCentroLocal.add(Etiqueta5);
PanelCentroLocal.add(CajaTextoCentro);
PanelCentroLocal.add(Etiqueta6);
Panel1.add(PanelEspacioArriba, BorderLayout.NORTH);
Panel1.add(PanelCedulaHistorico, BorderLayout.CENTER);
Panel1.add(PanelNombreHistorico, BorderLayout.SOUTH);
Panel2.add(PanelCarrera, BorderLayout.NORTH);
Panel2.add(PanelCentroLocal, BorderLayout.CENTER);
while (MiTabla.getRowCount() > 0)
{
MiTabla.removeRow(0);
}
Tabla.setPreferredScrollableViewportSize(new Dimension(590,175));
MiTabla.addColumn("Código");
MiTabla.addColumn("Asignatura");
MiTabla.addColumn("Semestre");
MiTabla.addColumn("U.C.");
MiTabla.addColumn("Calificación");
MiTabla.addColumn("Lapso");
while (Tabla.getColumnCount() > 6)
{
MiColumna = Tabla.getColumnModel().getColumn(6);
Tabla.removeColumn(MiColumna);
}
HisUCXCAL = 0;
HisTCreditos = 0;
HisIndice = 0;
//*** Para formato 1.000,00
nf = NumberFormat.getInstance();
nf.setMinimumFractionDigits(2);
nf.setMaximumFractionDigits(2);
//*** Se hace la conexión y se llena la tabla(listado) con los datos.
try
{
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM HISTORICO a, ASIGNATURAS b, PENSUM c" +
" WHERE a.CodigoAsignatura = b.CodigoAsignatura AND a.CodigoAsignatura =
c.CodigoAsignatura" +
" ORDER BY c.SemestreAsignatura,a.LapsoAsignatura,a.CodigoAsignatura";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
String ced = String.valueOf(rs.getInt("CedulaEstudiante"));
String cod = String.valueOf(rs.getInt("CodigoCarrera"));
if(ced.equals(MenuAdministrador.adsCedula2) &&
cod.equals(String.valueOf(IntHistorico.vCarrera)) ||
ced.equals(MenuEstudiante.adsCedula) &&
cod.equals(String.valueOf(IntHistorico.vCarrera)))
{
Fila[0] = String.valueOf(rs.getInt("CodigoAsignatura"));
Fila[1] = rs.getString("NombreAsignatura");
Fila[2] = String.valueOf(rs.getInt("SemestreAsignatura"));
Fila[3] = String.valueOf(rs.getInt("UCAsignatura"));
Fila[4] = String.valueOf(rs.getInt("CalificacionAsignatura"));
Fila[5] = rs.getString("LapsoAsignatura");
MiTabla.addRow(Fila);
HisUCXCAL = HisUCXCAL + (Double.parseDouble(Fila[3].toString()) *
Double.parseDouble(Fila[4].toString()));
HisTCreditos = HisTCreditos + Double.parseDouble(Fila[3].toString());
}
}
rs.close();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
}
PanelTabla.add(scrollPane, BorderLayout.CENTER);
if(MenuAdministrador.nMEU == true)
{
PanelBotones.add(BotonCalificacionNueva);
PanelBotones.add(Etiqueta9);
PanelBotones.add(BotonCambiarCalificacion);
PanelBotones.add(Etiqueta10);
PanelBotones.add(BotonEliminarCalificacion);
PanelBotones.add(Etiqueta11);
PanelBotones.add(BotonCancelarCalificacion);
BotonCalificacionNueva.setMnemonic('R');
BotonCalificacionNueva.setToolTipText("Registrar calificación...");
BotonCambiarCalificacion.setMnemonic('m');
BotonCambiarCalificacion.setToolTipText("Cambiar calificación...");
BotonEliminarCalificacion.setMnemonic('E');
BotonEliminarCalificacion.setToolTipText("Eliminar calificación...");
BotonCancelarCalificacion.setText("
Cancelar
");
BotonCancelarCalificacion.setMnemonic('C');
BotonCancelarCalificacion.setToolTipText("Cancelar y salir...");
}
else
{
if (HisUCXCAL == 0 && HisTCreditos == 0)
HisIndice = 0;
else
HisIndice = HisUCXCAL / HisTCreditos;
CajaTextoIndice.setEditable(false);
CajaTextoIndice.setText(nf.format(HisIndice));
PanelBotones.add(EtiquetaIndice);
PanelBotones.add(CajaTextoIndice);
PanelBotones.add(Etiqueta7);
PanelBotones.add(Etiqueta8);
PanelBotones.add(BotonCancelarCalificacion);
BotonCancelarCalificacion.setText("
Aceptar
");
BotonCancelarCalificacion.setMnemonic('A');
BotonCancelarCalificacion.setToolTipText("Salir de la consulta");
}
// *** Se agrega el panel principal al diálogo
PanelPricipal.add(Panel1);
PanelPricipal.add(Panel2);
PanelPricipal.add(PanelTabla);
PanelPricipal.add(PanelBotones);
getContentPane().add(PanelPricipal);
//*** Se desactiva maximizar/minimizar
setResizable(false);
// *** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
//*** Eventos producidos por los botones del diálogo
this.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
BotonCalificacionNueva.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoCalificacion
nIngresa = true;
nTituloHistorico = "Registrar calificación estudiante";
DialogoCalificacion d = new DialogoCalificacion();
d.setVisible(true);
}
});
BotonCambiarCalificacion.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se crea una instancia de la clase DialogoCalificacion
if (Tabla.getSelectedRow() == -1)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe seleccionar una asignatura de la tabla !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
else
{
HisCedula
HisAsiH =
HisCalH =
HisLapH =
= CajaTextoCedula.getText();
Tabla.getValueAt(Tabla.getSelectedRow(),0).toString();
Tabla.getValueAt(Tabla.getSelectedRow(),4).toString();
Tabla.getValueAt(Tabla.getSelectedRow(),5).toString();
nIngresa = false;
nTituloHistorico = "Cambiar calificación estudiante";
DialogoCalificacion d = new DialogoCalificacion();
d.setVisible(true);
}
}
});
BotonEliminarCalificacion.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
if (Tabla.getSelectedRow() == -1)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe seleccionar una asignatura de la tabla !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
else
{
Toolkit.getDefaultToolkit().beep();
int n = JOptionPane.showConfirmDialog(null,"¿ Quiere eliminar la asignatura y
calificación seleccionada ?",
"Eliminar...",JOptionPane.YES_NO_OPTION);
if (n == JOptionPane.YES_OPTION)
{
//*** Se invoca el método EliminarDatos de la clase ControlHistorico
HisCedula = CajaTextoCedula.getText();
HisAsiH = Tabla.getValueAt(Tabla.getSelectedRow(),0).toString();
HisCalH = Tabla.getValueAt(Tabla.getSelectedRow(),4).toString();
HisLapH = Tabla.getValueAt(Tabla.getSelectedRow(),5).toString();
IntHistorico.EliminarDatos(HisCedula,HisAsiH,HisCalH,HisLapH);
MiTabla.removeRow(Tabla.getSelectedRow());
}
}
}
});
BotonCancelarCalificacion.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
}
//*** Fin del constructor Historico
//*** Se definen los métodos necesarios para abrir y cerrar el diálogo
public void actionPerformed(ActionEvent e)
{
Object s = e.getSource();
}
public void CierraVentana()
{
if (MenuAdministrador.nIMEU == true || MenuEstudiante.nIMEU == true)
{
setVisible(false);
dispose();
}
else
{
setVisible( false );
dispose();
System.exit(0);
}
}
//*** Se crea una nueva clase para crear un diáologo que sirve para ingresar
//*** código asignatura, la calificación del estudiante y lapso
class DialogoCalificacion extends JDialog
{
//*** Se crean los componentes necesarios
JLabel EtiquetaAsignatura = new JLabel("Código asignatura :");
JLabel Etiqueta1 = new JLabel(" ");
JLabel Etiqueta2 = new JLabel("
");
JComboBox ComboAsignatura = new JComboBox();
JLabel EtiquetaCalificacion = new JLabel("Calificación :");
JLabel Etiqueta3 = new JLabel("
");
JLabel Etiqueta4 = new JLabel(" ");
String[] Calificacion = {"1","2","3","4","5","6","7","8","9","10"};
JComboBox ComboCalificacion = new JComboBox(Calificacion);
JLabel EtiquetaLapso =
JLabel Etiqueta5 = new
JLabel Etiqueta6 = new
JComboBox ComboLapso =
new JLabel("Lapso :");
JLabel("
JLabel("
new JComboBox();
JButton BotonAceptarCal = new JButton("
JLabel Etiqueta9 = new JLabel("
");
JButton BotonCancelarCal = new JButton("
");
");
Aceptar
Cancelar
");
");
public DialogoCalificacion()
{
//*** Se define el título y tamaño de la ventana
super(new Frame(), nTituloHistorico, true);
setBounds( 0, 0, 300, 228 );
//*** Se crean los páneles para acomodar los componentes
JPanel
JPanel
JPanel
JPanel
PanelEspacioArriba = new JPanel();
PanelAsignatura = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelCalificacion = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelLapso = new JPanel(new FlowLayout(FlowLayout.LEFT));
JPanel Panel1 = new JPanel(new BorderLayout(5,5));
JPanel Panel2 = new JPanel(new BorderLayout(5,5));
JPanel PanelBotones = new JPanel(new FlowLayout(FlowLayout.CENTER));
JPanel PanelPricipal = new JPanel(new FlowLayout(FlowLayout.CENTER));
//*** Se hace la conexión y se llena el ComboAsignatura con los
//*** datos de la tabla ASIGNATURA de la base de datos
try
{
int i = 0;
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM PENSUM ORDER BY CodigoAsignatura";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
String car = "";
if (Historico.CajaTextoCarrera.getText().equals("Ingeniería de Sistemas (236)"))
car = "236";
if (Historico.CajaTextoCarrera.getText().equals("Ingeniería Industrial (280)"))
car = "280";
if (Historico.CajaTextoCarrera.getText().equals("Administración de Empresas (612)"))
car = "612";
if (Historico.CajaTextoCarrera.getText().equals("Contaduría Pública (610)"))
car = "610";
if (rs.getString("CodigoCarrera").equals(car))
{
String asig = String.valueOf(rs.getInt("CodigoAsignatura"));
ComboAsignatura.addItem(asig);
i = i + 1;
}
}
rs.close();
nConectaB.close();
for(int j = 1990; j < 2011; j ++)
{
ComboLapso.addItem(String.valueOf(j) + "-1");
ComboLapso.addItem(String.valueOf(j) + "-2");
}
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
}
if (Historico.nIngresa == false)
{
ComboAsignatura.setSelectedItem(HisAsiH);
ComboCalificacion.setSelectedItem(HisCalH);
ComboLapso.setSelectedItem(HisLapH);
}
PanelAsignatura.add(EtiquetaAsignatura);
PanelAsignatura.add(Etiqueta1);
PanelAsignatura.add(ComboAsignatura);
PanelAsignatura.add(Etiqueta2);
PanelCalificacion.add(EtiquetaCalificacion);
PanelCalificacion.add(Etiqueta3);
PanelCalificacion.add(ComboCalificacion);
PanelCalificacion.add(Etiqueta4);
PanelLapso.add(EtiquetaLapso);
PanelLapso.add(Etiqueta5);
PanelLapso.add(ComboLapso);
PanelLapso.add(Etiqueta6);
Panel1.add(PanelEspacioArriba, BorderLayout.NORTH);
Panel1.add(PanelAsignatura, BorderLayout.CENTER);
Panel1.add(PanelCalificacion, BorderLayout.SOUTH);
Panel2.add(PanelLapso, BorderLayout.NORTH);
BotonAceptarCal.setMnemonic('A');
BotonAceptarCal.setToolTipText("Guardar calificación");
BotonCancelarCal.setMnemonic('C');
BotonCancelarCal.setToolTipText("Cancelar y salir");
PanelBotones.add(BotonAceptarCal);
PanelBotones.add(Etiqueta9);
PanelBotones.add(BotonCancelarCal);
PanelPricipal.add(Panel1);
PanelPricipal.add(Panel2);
PanelPricipal.add(PanelBotones);
getContentPane().add(PanelPricipal);
//*** Para no cambiar el tamaño de la ventana
setResizable(false);
//*** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
BotonAceptarCal.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
///*******************************
///*** VITAL
****
///*******************************
IntHistorico.nControl7 = true;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
MenuAdministrador.nControl3 = false;
MenuAdministrador.nControl4 = false;
MenuAdministrador.nControl6 = false;
MenuAdministrador.nControl9 = false;
MenuAdministrador.nControl11 = false;
HisAsiH = ComboAsignatura.getSelectedItem().toString();
HisCalH = ComboCalificacion.getSelectedItem().toString();
HisLapH = ComboLapso.getSelectedItem().toString();
IntHistorico.IniciarVariables();
IntHistorico.VerificarDatos();
dispose();
}
});
BotonCancelarCal.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
dispose();
}
});
}
//*** Fin del constructor DialogoCalificacion
}
//*** Fin de la clase DialogoCalificacion
}
//***************************************************************************
// Fin Clase Historico
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: Inscripciones (Crea un diálogo que sirve
****
//**** para ingresar, eliminar o mostrar las asignaturas selecionadas
****
//**** por el estudiante para la inscripción)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import
import
import
import
import
import
import
import
import
java.io.*;
java.sql.*;
java.awt.*;
java.awt.event.*;
javax.swing.*;
java.text.*;
java.util.Date;
javax.swing.table.DefaultTableModel;
javax.swing.table.TableColumn;
//***************************************************************************
// Inicio Clase Inscripciones
//***************************************************************************
public class Inscripciones extends JDialog
{
//*** Se declaran las variables
static boolean nInc = false;
static int IncCreditos = 0;
static int IncArancel = 0;
static NumberFormat nf;
String
String
String
String
Dia =
Mes =
Ano =
fecha
static
static
static
static
static
String
String
String
String
String
"";
"";
"";
= String.valueOf(new Date());
IntCod;
IntAsi;
IntSem;
IntUC;
IntLapso;
static boolean nIngresa = true;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se crea una instancia IntInscripciones de la clase ControlInscripciones para
//*** utilizar los métodos de esta clase y hacer las transacciones con la
//*** tabla INSCRIPCIONES de la base de datos
ControlInscripciones IntInscripciones = new ControlInscripciones();
JLabel Etiqueta0 = new JLabel("
");
JLabel ICedula = new JLabel("No. de cédula : ");
JLabel Etiqueta1 = new JLabel(" ");
static TextField CajaTextoICedula = new TextField(10);
JLabel ICentro = new JLabel("Centro local : ");
JLabel Etiqueta2 = new JLabel(" ");
static TextField CajaTextoICentro = new TextField(20);
JLabel ICarrera = new JLabel("Carrera : ");
JLabel Etiqueta3 = new JLabel(" ");
static TextField CajaTextoICarrera = new TextField(30);
JLabel INombre = new JLabel("Nombre
: ");
JLabel Etiqueta4 = new JLabel(" ");
static TextField CajaTextoINombre = new TextField(47);
JLabel ILapso = new JLabel("Lapso
: ");
JLabel Etiqueta5 = new JLabel(" ");
static TextField CajaTextoILapso = new TextField(10);
static
static
static
static
static
DefaultTableModel MiTabla1 = new DefaultTableModel();
JTable Tabla1 = new JTable(MiTabla1);
JScrollPane scrollPane1 = new JScrollPane(Tabla1);
Object [] Fila1 = new Object[4];
TableColumn MiColumna1 = new TableColumn();
static
static
static
static
static
DefaultTableModel MiTabla2 = new DefaultTableModel();
JTable Tabla2 = new JTable(MiTabla2);
JScrollPane scrollPane2 = new JScrollPane(Tabla2);
Object [] Fila2 = new Object[5];
TableColumn MiColumna2 = new TableColumn();
JLabel
JLabel
JLabel
JLabel
static
JLabel
static
Etiqueta6 = new JLabel("
Etiqueta7 = new JLabel("
Etiqueta8 = new JLabel("
TotalCreditos = new JLabel("Total créditos : ");
TextField CajaTextoCreditos = new TextField(10);
TotalAranceles = new JLabel("Total aranceles : ");
TextField CajaTextoAranceles = new TextField(10);
");
");
");
JButton BotonGuardarInscripcion = new JButton("
Guardar
");
JLabel Etiqueta11 = new JLabel("
");
JButton BotonAdicionarMateria = new JButton("
Añadir
");
JLabel Etiqueta12 = new JLabel("
");
JButton BotonQuitarMateria = new JButton("
Quitar
");
JLabel Etiqueta13 = new JLabel("
");
JButton BotonCancelarInscripciones = new JButton("
Cancelar
");
//*** Se define el método principal "main" de la Clase Inscripciones
public static void main(String g[])
{
//*** Se ejecuta el constructor Inscripciones de la clase Inscripciones
Inscripciones p = new Inscripciones();
p.setVisible(true);
//*** Para cerrar la ventana
p.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
});
}
//*** Inicio del constructor Inscripciones
Inscripciones()
{
//*** Se define el título de la ventana
super(new Frame(), "Inscripción regular", true);
//*** Se define el tamaño de la ventana para el diálogo
setBounds( 0, 0, 800, 535 );
//*** Se crean los páneles para acomodar los componentes
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
PanelEspacioArriba = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelI1 = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelI2 = new JPanel(new FlowLayout(FlowLayout.LEFT));
Panel1 = new JPanel(new GridLayout(3,1,2,2));
PanelTablas = new JPanel(new GridLayout(2,1,15,10));
PanelAranceles = new JPanel(new FlowLayout(FlowLayout.RIGHT));
PanelBotones = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelPricipal = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelEspacioArriba.add(Etiqueta0);
CajaTextoICedula.setEditable(false);
CajaTextoICedula.setText(MenuAdministrador.adsCedula3);
CajaTextoICentro.setEditable(false);
CajaTextoICentro.setText(IntInscripciones.vCentro);
CajaTextoICarrera.setEditable(false);
CajaTextoICarrera.setText(IntInscripciones.vCarrera);
PanelI1.add(ICedula);
PanelI1.add(CajaTextoICedula);
PanelI1.add(Etiqueta1);
PanelI1.add(ICentro);
PanelI1.add(CajaTextoICentro);
PanelI1.add(Etiqueta2);
PanelI1.add(ICarrera);
PanelI1.add(CajaTextoICarrera);
CajaTextoINombre.setEditable(false);
CajaTextoINombre.setText(IntInscripciones.vNombre);
CajaTextoILapso.setEditable(false);
Mes = fecha.substring(4,7);
Dia = fecha.substring(8,10);
Ano = fecha.substring(fecha.length() - 4, fecha.length());
if (Mes.equals("Jan") || Mes.equals("Feb") || Mes.equals("Mar") || Mes.equals("Apr") ||
Mes.equals("May") || Mes.equals("Jun"))
{
IntLapso = Ano + "-1";
CajaTextoILapso.setText(IntLapso);
}
else
{
IntLapso = Ano + "-2";
CajaTextoILapso.setText(IntLapso);
}
PanelI2.add(INombre);
PanelI2.add(CajaTextoINombre);
PanelI2.add(Etiqueta4);
PanelI2.add(ILapso);
PanelI2.add(CajaTextoILapso);
Panel1.add(PanelEspacioArriba, BorderLayout.CENTER);
Panel1.add(PanelI1, BorderLayout.CENTER);
Panel1.add(PanelI2, BorderLayout.CENTER);
//*** TABLA1 ***
while (MiTabla1.getRowCount() > 0)
{
MiTabla1.removeRow(0);
}
Tabla1.setPreferredScrollableViewportSize(new Dimension(735,127));
MiTabla1.addColumn("Código asignatura");
MiTabla1.addColumn("Nombre asignatura");
MiTabla1.addColumn("Semestre");
MiTabla1.addColumn("U.C.");
while (Tabla1.getColumnCount() > 4)
{
MiColumna1 = Tabla1.getColumnModel().getColumn(4);
Tabla1.removeColumn(MiColumna1);
}
//*** Se hace la conexión y se llena la tabla (listado) con los datos.
try
{
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM ASIGNATURAS a, PENSUM b" +
" WHERE a.CodigoAsignatura = b.CodigoAsignatura" +
" ORDER BY b.CodigoCarrera,b.SemestreAsignatura,a.CodigoAsignatura";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
boolean nPrerequisito1 = false;
boolean nPrerequisito2 = false;
boolean nPrerequisito3 = false;
boolean nPrerequisito4 = false;
while (rs.next())
{
int cod = rs.getInt("CodigoCarrera");
if(cod == IntInscripciones.car)
{
int cod1 = rs.getInt("CodigoPreRequisito1");
int cod2 = rs.getInt("CodigoPreRequisito2");
int cod3 = rs.getInt("CodigoPreRequisito3");
int cod4 = rs.getInt("CodigoPreRequisito4");
if (cod1 > 0)
{
if ((IntInscripciones.BuscarCalificacion(MenuAdministrador.adsCedula3,cod1) ==
true &&
MenuEstudiante.adsCedula == "") ||
(IntInscripciones.BuscarCalificacion(MenuEstudiante.adsCedula,cod1) == true
&&
MenuAdministrador.adsCedula3 == ""))
nPrerequisito1 = true;
else
nPrerequisito1 = false;
}
else
{
nPrerequisito1 = true;
}
if (cod2 > 0)
{
if ((IntInscripciones.BuscarCalificacion(MenuAdministrador.adsCedula3,cod2) ==
true &&
MenuEstudiante.adsCedula == "") ||
(IntInscripciones.BuscarCalificacion(MenuEstudiante.adsCedula,cod2) == true
&&
MenuAdministrador.adsCedula3 == ""))
nPrerequisito2 = true;
else
nPrerequisito2 = false;
}
else
{
nPrerequisito2 = true;
}
if (cod3 > 0)
{
if ((IntInscripciones.BuscarCalificacion(MenuAdministrador.adsCedula3,cod3) ==
true &&
MenuEstudiante.adsCedula == "") ||
(IntInscripciones.BuscarCalificacion(MenuEstudiante.adsCedula,cod3) == true
&&
MenuAdministrador.adsCedula3 == ""))
nPrerequisito3 = true;
else
nPrerequisito3 = false;
}
else
{
nPrerequisito3 = true;
}
if (cod4 > 0)
{
if ((IntInscripciones.BuscarCalificacion(MenuAdministrador.adsCedula3,cod4) ==
true &&
MenuEstudiante.adsCedula == "") ||
(IntInscripciones.BuscarCalificacion(MenuEstudiante.adsCedula,cod4) == true
&&
MenuAdministrador.adsCedula3 == ""))
nPrerequisito4 = true;
else
nPrerequisito4 = false;
}
else
{
nPrerequisito4 = true;
}
if (nPrerequisito1 == true && nPrerequisito2 == true && nPrerequisito3 == true &&
nPrerequisito4 == true)
{
Fila1[0] = String.valueOf(rs.getInt("CodigoAsignatura"));
Fila1[1] = rs.getString("NombreAsignatura");
Fila1[2] = String.valueOf(rs.getInt("SemestreAsignatura"));
Fila1[3] = String.valueOf(rs.getInt("UCAsignatura"));
String cod5 = Fila1[0].toString();
int cod6 = Integer.parseInt(cod5);
if ((IntInscripciones.BuscarCalificacion(MenuAdministrador.adsCedula3,cod6) ==
false &&
MenuEstudiante.adsCedula == "") ||
(IntInscripciones.BuscarCalificacion(MenuEstudiante.adsCedula,cod6) == false
&&
MenuAdministrador.adsCedula3 == ""))
MiTabla1.addRow(Fila1);
}
}
}
rs.close();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
}
//*** TABLA2 ***
while (MiTabla2.getRowCount() > 0)
{
MiTabla2.removeRow(0);
}
Tabla2.setPreferredScrollableViewportSize(new Dimension(735,127));
MiTabla2.addColumn("Código");
MiTabla2.addColumn("Asignatura");
MiTabla2.addColumn("Semestre");
MiTabla2.addColumn("U.C.");
MiTabla2.addColumn("Arancel");
while (Tabla2.getColumnCount() > 5)
{
MiColumna2 = Tabla2.getColumnModel().getColumn(5);
Tabla2.removeColumn(MiColumna2);
}
IncCreditos = 0;
IncArancel = 0;
//*** Para formato 1.000,00
nf = NumberFormat.getInstance();
nf.setMinimumFractionDigits(2);
nf.setMaximumFractionDigits(2);
//*** Se hace la conexión y se llena la tabla (listado) con los datos.
try
{
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM INSCRIPCIONES a, ASIGNATURAS b, PENSUM c" +
" WHERE a.CodigoAsignatura = b.CodigoAsignatura AND a.CodigoAsignatura =
c.CodigoAsignatura" +
" AND a.CodigoCarrera = c.CodigoCarrera" +
" ORDER BY c.CodigoAsignatura";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
String ced = String.valueOf(rs.getInt("CedulaEstudiante"));
String lap = rs.getString("LapsoInscripcion");
if(ced.equals(MenuAdministrador.adsCedula3) && lap.equals(IntLapso) ||
ced.equals(MenuEstudiante.adsCedula) && lap.equals(IntLapso))
{
Fila2[0] = String.valueOf(rs.getInt("CodigoAsignatura"));
Fila2[1] = rs.getString("NombreAsignatura");
Fila2[2] = String.valueOf(rs.getInt("SemestreAsignatura"));
Fila2[3] = String.valueOf(rs.getInt("UCAsignatura"));
Fila2[4] = "1.000,00";
MiTabla2.addRow(Fila2);
IncCreditos = IncCreditos + Integer.parseInt(Fila2[3].toString());
IncArancel = IncArancel + 1000;
}
}
rs.close();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
}
CajaTextoCreditos.setText(nf.format(IncCreditos));
CajaTextoAranceles.setText(nf.format(IncArancel));
PanelTablas.add(scrollPane1, BorderLayout.CENTER);
PanelTablas.add(scrollPane2, BorderLayout.CENTER);
PanelTablas.add(PanelAranceles, BorderLayout.CENTER);
CajaTextoCreditos.setEditable(false);
CajaTextoAranceles.setEditable(false);
PanelAranceles.add(Etiqueta6);
PanelAranceles.add(Etiqueta7);
PanelAranceles.add(TotalCreditos);
PanelAranceles.add(CajaTextoCreditos);
PanelAranceles.add(Etiqueta8);
PanelAranceles.add(TotalAranceles);
PanelAranceles.add(CajaTextoAranceles);
PanelBotones.add(BotonGuardarInscripcion);
PanelBotones.add(Etiqueta11);
PanelBotones.add(BotonAdicionarMateria);
PanelBotones.add(Etiqueta12);
PanelBotones.add(BotonQuitarMateria);
PanelBotones.add(Etiqueta13);
PanelBotones.add(BotonCancelarInscripciones);
BotonGuardarInscripcion.setMnemonic('G');
BotonGuardarInscripcion.setToolTipText("Guardar selección de asignaturas");
BotonAdicionarMateria.setMnemonic('A');
BotonAdicionarMateria.setToolTipText("Añadir una asignatura");
BotonQuitarMateria.setMnemonic('Q');
BotonQuitarMateria.setToolTipText("Quitar una asignatura");
BotonCancelarInscripciones.setMnemonic('C');
BotonCancelarInscripciones.setToolTipText("Cancelar y salir...");
// *** Se agrega el panel principal al diálogo
PanelPricipal.add(Panel1);
PanelPricipal.add(PanelTablas);
PanelPricipal.add(PanelAranceles);
PanelPricipal.add(PanelBotones);
getContentPane().add(PanelPricipal);
//*** Se desactiva maximizar/minimizar
setResizable(false);
// *** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
//*** Eventos producidos por los botones del diálogo
this.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
BotonGuardarInscripcion.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
///*******************************
///*** VITAL
****
///*******************************
IntInscripciones.nControl10 = true;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlValidaciones.nControl12 = false;
MenuAdministrador.nControl3 = false;
MenuAdministrador.nControl4 = false;
MenuAdministrador.nControl6 = false;
MenuAdministrador.nControl9 = false;
MenuAdministrador.nControl11 = false;
IntInscripciones.IniciarVariables();
IntInscripciones.VerificarDatos();
if (nInc == true)
{
nInc = false;
CierraVentana();
}
}
});
BotonAdicionarMateria.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
if (Tabla1.getSelectedRow() == -1)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe seleccionar una asignatura de la tabla 1 !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
else
{
IntCod = Tabla1.getValueAt(Tabla1.getSelectedRow(),0).toString();
IntAsi = Tabla1.getValueAt(Tabla1.getSelectedRow(),1).toString();
IntSem = Tabla1.getValueAt(Tabla1.getSelectedRow(),2).toString();
IntUC = Tabla1.getValueAt(Tabla1.getSelectedRow(),3).toString();
boolean nExisteAsig = false;
for (int i=0; i<MiTabla2.getRowCount(); i++)
{
if(IntCod.equals(MiTabla2.getValueAt(i,0).toString()))
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ La asignatura " + IntCod + " ya fue seleccionada !!","Atención",
JOptionPane.WARNING_MESSAGE);
nExisteAsig = true;
break;
}
}
if (nExisteAsig == false)
{
IncCreditos = IncCreditos + Integer.parseInt(IntUC);
IncArancel = IncArancel + 1000;
if (IncCreditos > 21)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Sólo se permite inscribir un máximo de 21 créditos !!","Atención",
JOptionPane.WARNING_MESSAGE);
IncCreditos = IncCreditos - Integer.parseInt(IntUC);
IncArancel = IncArancel - 1000;
}
else
{
Fila2[0] = IntCod;
Fila2[1] = IntAsi;
Fila2[2] = IntSem;
Fila2[3] = IntUC;
Fila2[4] = "1.000,00";
MiTabla2.addRow(Fila2);
CajaTextoCreditos.setText(nf.format(IncCreditos));
CajaTextoAranceles.setText(nf.format(IncArancel));
}
}
}
}
});
BotonQuitarMateria.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
if (Tabla2.getSelectedRow() == -1)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe seleccionar una asignatura de la tabla 2 !!","Atención",
JOptionPane.WARNING_MESSAGE);
}
else
{
IntUC = Tabla2.getValueAt(Tabla2.getSelectedRow(),3).toString();
IncCreditos = IncCreditos - Integer.parseInt(IntUC);
IncArancel = IncArancel - 1000;
MiTabla2.removeRow(Tabla2.getSelectedRow());
CajaTextoCreditos.setText(nf.format(IncCreditos));
CajaTextoAranceles.setText(nf.format(IncArancel));
}
}
});
BotonCancelarInscripciones.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
}
//*** Fin del constructor Inscripciones
//*** Se definen los métodos necesarios para abrir, cerrar las ventanas e
//*** iniciar etiquetas
public void actionPerformed(ActionEvent e)
{
Object s = e.getSource();
}
public void CierraVentana()
{
if (MenuAdministrador.nIMEU == true || MenuEstudiante.nIMEU == true)
{
setVisible(false);
dispose();
}
else
{
setVisible( false );
dispose();
System.exit(0);
}
}
}
//***************************************************************************
// Fin Clase Inscripciones
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: Validaciones (Crea un diálogo que sirve
****
//**** para validar la inscripción del estudiante)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import
import
import
import
import
import
import
java.io.*;
java.sql.*;
java.awt.*;
java.awt.event.*;
javax.swing.*;
java.text.*;
java.util.Date;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableColumn;
//***************************************************************************
// Inicio Clase Validaciones
//***************************************************************************
public class Validaciones extends JDialog
{
//*** Se declaran las variables
static boolean nVal = false;
static int ValCreditos = 0;
static int ValArancel = 0;
NumberFormat nf;
String
String
String
String
Dia =
Mes =
Ano =
fecha
static
static
static
static
static
static
static
static
static
String
String
String
String
String
String
String
String
String
"";
"";
"";
= String.valueOf(new Date());
IntCed;
IntLapso;
IntBanco;
IntNumero;
IntDia;
IntMes;
IntAno;
IntMonto;
IntValida;
static boolean nIngresa = true;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se crea una instancia IntValidaciones de la clase ControlValidaciones para
//*** utilizar los métodos de esta clase y hacer las transacciones con la
//*** tabla VALIDACIONES
ControlValidaciones IntValidaciones = new ControlValidaciones();
JLabel Etiqueta0 = new JLabel("
");
JLabel EtiquetaVCedula = new JLabel("No. de cédula : ");
JLabel Etiqueta1 = new JLabel(" ");
static TextField CajaTextoVCedula = new TextField(10);
JLabel EtiquetaVCentro = new JLabel("Centro local : ");
JLabel Etiqueta2 = new JLabel(" ");
static TextField CajaTextoVCentro = new TextField(20);
JLabel EtiquetaVCarrera = new JLabel("Carrera : ");
JLabel Etiqueta3 = new JLabel(" ");
static TextField CajaTextoVCarrera = new TextField(30);
JLabel EtiquetaVNombre = new JLabel("Nombre
: ");
JLabel Etiqueta4 = new JLabel(" ");
static TextField CajaTextoVNombre = new TextField(47);
JLabel EtiquetaVLapso = new JLabel("Lapso
: ");
JLabel Etiqueta5 = new JLabel(" ");
static TextField CajaTextoVLapso = new TextField(10);
static
static
static
static
static
DefaultTableModel MiTabla1 = new DefaultTableModel();
JTable Tabla1 = new JTable(MiTabla1);
JScrollPane scrollPane1 = new JScrollPane(Tabla1);
Object [] Fila1 = new Object[5];
TableColumn MiColumna1 = new TableColumn();
JLabel Etiqueta6 = new JLabel("
JLabel Etiqueta7 = new JLabel("
");
");
JLabel
JLabel
static
JLabel
static
Etiqueta8 = new JLabel("
TotalCreditos = new JLabel("Total créditos : ");
TextField CajaTextoCreditos = new TextField(10);
TotalAranceles = new JLabel("Total aranceles : ");
TextField CajaTextoAranceles = new TextField(10);
");
JLabel
JLabel
JLabel
static
EtiquetaBanco = new JLabel("Banco : ");
Etiqueta14 = new JLabel("");
Etiqueta15 = new JLabel("");
String[] Banco = {"Venezuela (0102203838)","Provincial (0349003940)",
"Caribe (0456201238)","Exterior (02450045340)"};
JComboBox ComboBanco = new JComboBox(Banco);
JLabel EtiquetaNumDeposito = new JLabel("No. dep. : ");
JLabel Etiqueta16 = new JLabel(" ");
static TextField CajaTextoNumDeposito = new TextField(10);
JLabel EtiquetaFecDeposito = new JLabel("Fecha : ");
JLabel Etiqueta17 = new JLabel(" ");
static String[] cDia = {"1","2","3","4","5","6","7","8","9","10","11","12","13","14","15",
"16","17","18","19","20","21","22","23","24","25","26","27","28",
"29","30","31" };
JComboBox ComboDia = new JComboBox(cDia);
static String[] cMes = {"1","2","3","4","5","6","7","8","9","10","11","12"};
JComboBox ComboMes = new JComboBox(cMes);
static String[] cAno = {"1975","1976","1977","1978","1979","1980","1981","1982","1983","1984",
"1985","1986","1987","1988","1989","1990","1991","1992","1993","1994",
"1995","1996","1997","1998","1999","2000","2001","2002","2003","2004",
"2005","2006","2007","2008","2009","2010","2011","2012","2013","2014",};
JComboBox ComboAno = new JComboBox(cAno);
JLabel EtiquetaMonDeposito = new JLabel("Monto : ");
JLabel Etiqueta18 = new JLabel(" ");
static TextField CajaTextoMonDeposito = new TextField(10);
JLabel EtiquetaValidar = new JLabel(" Validar inscripción :");
JLabel Etiqueta19 = new JLabel("
JLabel Etiqueta20 = new JLabel("
JLabel Etiqueta21 = new JLabel("
");
JCheckBox CheckValidar = new JCheckBox();
JButton BotonGuardarRegistro = new JButton("
JLabel Etiqueta10 = new JLabel("
");
JButton BotonEliminarRegistro = new JButton("
JLabel Etiqueta11 = new JLabel("
");
JButton BotonImprimirRegistro = new JButton("
JLabel Etiqueta13 = new JLabel("
");
JButton BotonCancelarRegistro = new JButton("
Guardar
");
");
");
Eliminar
");
Imprimir
");
Cancelar
");
//*** Se define el método principal "main" de la Clase Validaciones
public static void main(String g[])
{
//*** Se ejecuta el constructor Validaciones de la clase Validaciones
Validaciones p = new Validaciones();
p.setVisible(true);
//*** Para cerrar la ventana
p.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
});
}
//*** Inicio del constructor Validaciones
Validaciones()
{
//*** Se define el título de la ventana
super(new Frame(), "Validar inscripción", true);
//*** Se define el tamaño de la ventana para el diálogo
setBounds( 0, 0, 800, 470 );
//*** Se crean los páneles para acomodar los componentes
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
PanelEspacioArriba = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelI1 = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelI2 = new JPanel(new FlowLayout(FlowLayout.LEFT));
Panel1 = new JPanel(new GridLayout(3,1,2,2));
PanelTablas = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelAranceles = new JPanel(new FlowLayout(FlowLayout.RIGHT));
PanelBanco = new JPanel(new FlowLayout(FlowLayout.LEFT));
PanelValidar = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelBotones = new JPanel(new FlowLayout(FlowLayout.CENTER));
PanelPricipal = new JPanel(new FlowLayout(FlowLayout.CENTER));
CajaTextoVCedula.setText(MenuAdministrador.adsCedula4);
CajaTextoVCentro.setText(IntValidaciones.nCentro);
CajaTextoVCarrera.setText(IntValidaciones.nCarrera);
CajaTextoVNombre.setText(IntValidaciones.nNombre);
Mes = fecha.substring(4,7);
Dia = fecha.substring(8,10);
Ano = fecha.substring(fecha.length() - 4, fecha.length());
if (Mes.equals("Jan") || Mes.equals("Feb") || Mes.equals("Mar") || Mes.equals("Apr") ||
Mes.equals("May") || Mes.equals("Jun"))
{
IntLapso = Ano + "-1";
CajaTextoVLapso.setText(IntLapso);
}
else
{
IntLapso = Ano + "-2";
CajaTextoVLapso.setText(IntLapso);
}
//*** TABLA1 ***
while (MiTabla1.getRowCount() > 0)
{
MiTabla1.removeRow(0);
}
Tabla1.setPreferredScrollableViewportSize(new Dimension(735,127));
MiTabla1.addColumn("Código");
MiTabla1.addColumn("Asignatura");
MiTabla1.addColumn("Semestre");
MiTabla1.addColumn("U.C.");
MiTabla1.addColumn("Arancel");
while (Tabla1.getColumnCount() > 5)
{
MiColumna1 = Tabla1.getColumnModel().getColumn(5);
Tabla1.removeColumn(MiColumna1);
}
ValCreditos = 0;
ValArancel = 0;
//*** Para formato 1.000,00
nf = NumberFormat.getInstance();
nf.setMinimumFractionDigits(2);
nf.setMaximumFractionDigits(2);
//*** Se hace la conexión y se llena la tabla (listado) con los datos.
try
{
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM INSCRIPCIONES a, ASIGNATURAS b, PENSUM c" +
" WHERE a.CodigoAsignatura = b.CodigoAsignatura AND a.CodigoAsignatura =
c.CodigoAsignatura" +
" AND a.CodigoCarrera = c.CodigoCarrera" +
" ORDER BY c.CodigoAsignatura";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
String ced = String.valueOf(rs.getInt("CedulaEstudiante"));
String lap = rs.getString("LapsoInscripcion");
if(ced.equals(MenuAdministrador.adsCedula4) && lap.equals(IntLapso) ||
ced.equals(MenuEstudiante.adsCedula) && lap.equals(IntLapso) )
{
Fila1[0]
Fila1[1]
Fila1[2]
Fila1[3]
Fila1[4]
=
=
=
=
=
String.valueOf(rs.getInt("CodigoAsignatura"));
rs.getString("NombreAsignatura");
String.valueOf(rs.getInt("SemestreAsignatura"));
String.valueOf(rs.getInt("UCAsignatura"));
"1.000,00";
MiTabla1.addRow(Fila1);
ValCreditos = ValCreditos + Integer.parseInt(Fila1[3].toString());
ValArancel = ValArancel + 1000;
}
}
rs.close();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
}
CajaTextoCreditos.setText(nf.format(ValCreditos));
CajaTextoAranceles.setText(nf.format(ValArancel));
CajaTextoVCedula.setEditable(false);
CajaTextoVCentro.setEditable(false);
CajaTextoVCarrera.setEditable(false);
CajaTextoVNombre.setEditable(false);
CajaTextoVLapso.setEditable(false);
CajaTextoCreditos.setEditable(false);
CajaTextoAranceles.setEditable(false);
PanelEspacioArriba.add(Etiqueta0);
PanelI1.add(EtiquetaVCedula);
PanelI1.add(CajaTextoVCedula);
PanelI1.add(Etiqueta1);
PanelI1.add(EtiquetaVCentro);
PanelI1.add(CajaTextoVCentro);
PanelI1.add(Etiqueta2);
PanelI1.add(EtiquetaVCarrera);
PanelI1.add(CajaTextoVCarrera);
PanelI2.add(EtiquetaVNombre);
PanelI2.add(CajaTextoVNombre);
PanelI2.add(Etiqueta4);
PanelI2.add(EtiquetaVLapso);
PanelI2.add(CajaTextoVLapso);
Panel1.add(PanelEspacioArriba, BorderLayout.CENTER);
Panel1.add(PanelI1, BorderLayout.CENTER);
Panel1.add(PanelI2, BorderLayout.CENTER);
PanelTablas.add(scrollPane1, BorderLayout.CENTER);
PanelAranceles.add(Etiqueta6);
PanelAranceles.add(Etiqueta7);
PanelAranceles.add(TotalCreditos);
PanelAranceles.add(CajaTextoCreditos);
PanelAranceles.add(Etiqueta8);
PanelAranceles.add(TotalAranceles);
PanelAranceles.add(CajaTextoAranceles);
ComboDia.setMaximumRowCount(5);
ComboMes.setMaximumRowCount(5);
ComboAno.setMaximumRowCount(5);
PanelBanco.add(EtiquetaBanco);
PanelBanco.add(ComboBanco);
PanelBanco.add(Etiqueta16);
PanelBanco.add(EtiquetaNumDeposito);
PanelBanco.add(CajaTextoNumDeposito);
PanelBanco.add(Etiqueta17);
PanelBanco.add(EtiquetaFecDeposito);
PanelBanco.add(ComboDia);
PanelBanco.add(ComboMes);
PanelBanco.add(ComboAno);
PanelBanco.add(Etiqueta18);
PanelBanco.add(EtiquetaMonDeposito);
PanelBanco.add(CajaTextoMonDeposito);
PanelValidar.add(Etiqueta19);
PanelValidar.add(EtiquetaValidar);
PanelValidar.add(CheckValidar);
PanelValidar.add(Etiqueta20);
PanelBotones.add(BotonGuardarRegistro);
PanelBotones.add(Etiqueta10);
PanelBotones.add(BotonEliminarRegistro);
PanelBotones.add(Etiqueta11);
PanelBotones.add(BotonImprimirRegistro);
PanelBotones.add(Etiqueta13);
PanelBotones.add(BotonCancelarRegistro);
//*** Verifica si existe el registro de la inscripción
if((!MenuAdministrador.adsCedula4.equals("") && !IntLapso.equals("")) ||
(!MenuEstudiante.adsCedula.equals("") && !IntLapso.equals("")))
{
if(IntValidaciones.BuscarRegistro(MenuAdministrador.adsCedula4,IntLapso) == true ||
IntValidaciones.BuscarRegistro(MenuEstudiante.adsCedula,IntLapso) == true)
{
ComboBanco.setSelectedItem(IntValidaciones.nBanco);
CajaTextoNumDeposito.setText(IntValidaciones.nNumero);
ComboDia.setSelectedItem(IntValidaciones.nDia);
ComboMes.setSelectedItem(IntValidaciones.nMes);
ComboAno.setSelectedItem(IntValidaciones.nAno);
CajaTextoMonDeposito.setText(IntValidaciones.nMonto);
if (IntValidaciones.nValida.equals("1"))
CheckValidar.setSelected(true);
if (IntValidaciones.nValida.equals("0"))
CheckValidar.setSelected(false);
BotonEliminarRegistro.setVisible(true);
BotonImprimirRegistro.setVisible(true);
}
else
{
ComboBanco.setSelectedIndex(0);
CajaTextoNumDeposito.setText("");
ComboDia.setSelectedIndex(0);
ComboMes.setSelectedIndex(0);
ComboAno.setSelectedItem(Ano);
CajaTextoMonDeposito.setText("");
CheckValidar.setSelected(false);
BotonEliminarRegistro.setVisible(false);
BotonImprimirRegistro.setVisible(false);
}
}
else
{
ComboBanco.setSelectedIndex(0);
CajaTextoNumDeposito.setText("");
ComboDia.setSelectedIndex(0);
ComboMes.setSelectedIndex(0);
ComboAno.setSelectedItem(Ano);
CajaTextoMonDeposito.setText("");
CheckValidar.setSelected(false);
BotonEliminarRegistro.setVisible(false);
BotonImprimirRegistro.setVisible(false);
}
BotonGuardarRegistro.setMnemonic('G');
BotonGuardarRegistro.setToolTipText("Guardar registro de inscripción");
BotonEliminarRegistro.setMnemonic('E');
BotonEliminarRegistro.setToolTipText("Eliminar registro de inscripción");
BotonImprimirRegistro.setMnemonic('I');
BotonImprimirRegistro.setToolTipText("Imprimir la planilla de inscripción");
BotonCancelarRegistro.setMnemonic('C');
BotonCancelarRegistro.setToolTipText("Cancelar y salir...");
// *** Se agrega el panel principal al diálogo
PanelPricipal.add(Panel1);
PanelPricipal.add(PanelTablas);
PanelPricipal.add(PanelAranceles);
PanelPricipal.add(PanelBanco);
PanelPricipal.add(PanelValidar);
PanelPricipal.add(PanelBotones);
getContentPane().add(PanelPricipal);
//*** Se desactiva maximizar/minimizar
setResizable(false);
// *** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
//*** Eventos producidos por los botones del diálogo
this.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
BotonGuardarRegistro.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
///*******************************
///*** VITAL
****
///*******************************
IntValidaciones.nControl12 = true;
ControlPassword.nControl1 = false;
ControlUsuarios.nControl2 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
MenuAdministrador.nControl3 = false;
MenuAdministrador.nControl4 = false;
MenuAdministrador.nControl6 = false;
MenuAdministrador.nControl9 = false;
MenuAdministrador.nControl11 = false;
IntCed = CajaTextoVCedula.getText();
IntLapso = CajaTextoVLapso.getText();
IntBanco = ComboBanco.getSelectedItem().toString();
IntNumero = CajaTextoNumDeposito.getText();
IntDia = ComboDia.getSelectedItem().toString();
IntMes = ComboMes.getSelectedItem().toString();
IntAno = ComboAno.getSelectedItem().toString();
IntMonto = CajaTextoMonDeposito.getText();
if (CheckValidar.isSelected() == true)
IntValida = "1";
if (CheckValidar.isSelected() == false)
IntValida = "0";
IntValidaciones.IniciarVariables();
IntValidaciones.VerificarDatos();
if (nVal == true)
{
nVal = false;
CierraVentana();
Toolkit.getDefaultToolkit().beep();
int n = JOptionPane.showConfirmDialog(null,"¿ Quiere imprimir la planilla de inscripción
?",
"Imprimir...",JOptionPane.YES_NO_OPTION);
if (n == JOptionPane.YES_OPTION)
IntValidaciones.ImprimePlanilla();
}
}
});
BotonEliminarRegistro.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
{
Toolkit.getDefaultToolkit().beep();
int n = JOptionPane.showConfirmDialog(null,"¿ Quiere eliminar este registro de
inscripción ?",
"Eliminar...",JOptionPane.YES_NO_OPTION);
if (n == JOptionPane.YES_OPTION)
{
//*** Se invoca el método EliminarDatos de la clase ControlValidaciones
IntCed = CajaTextoVCedula.getText();
IntLapso = CajaTextoVLapso.getText();
IntValidaciones.EliminarDatos(IntCed,IntLapso);
CierraVentana();
}
}
}
});
BotonImprimirRegistro.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
IntCed = CajaTextoVCedula.getText();
IntLapso = CajaTextoVLapso.getText();
IntBanco = ComboBanco.getSelectedItem().toString();
IntNumero = CajaTextoNumDeposito.getText();
IntDia = ComboDia.getSelectedItem().toString();
IntMes = ComboMes.getSelectedItem().toString();
IntAno = ComboAno.getSelectedItem().toString();
IntMonto = CajaTextoMonDeposito.getText();
if(!IntCed.equals("") && !IntNumero.equals("") && !IntMonto.equals(""))
{
CierraVentana();
IntValidaciones.ImprimePlanilla();
}
}
});
BotonCancelarRegistro.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
}
//*** Fin del constructor Validaciones
//*** Se definen los métodos necesarios para abrir y cerrar el diálogo
public void actionPerformed(ActionEvent e)
{
Object s = e.getSource();
}
public void CierraVentana()
{
if (MenuAdministrador.nIMEU == true || MenuEstudiante.nIMEU == true)
{
setVisible(false);
dispose();
}
else
{
setVisible( false );
dispose();
System.exit(0);
}
}
}
//***************************************************************************
// Fin Clase Validaciones
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: Usuarios (Crea un diálogo que sirve para
****
//**** ingresar o mostrar los datos de usuario y contraseña)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
//***************************************************************************
// Inicio Clase Usuarios
//***************************************************************************
public class Usuarios extends JDialog
{
//*** Se declaran las variables
static boolean nUsu = false;
static int UsuNivel;
static boolean nIngresa = true;
//*** Se crea una instancia IntUsuarios de la clase ControlUsuarios para
//*** utilizar los métodos de esta clase y hacer las transacciones con la
//*** tabla USUARIOS de la base de datos
ControlUsuarios IntUsuarios = new ControlUsuarios();
//*** Se crean los componentes necesarios
JLabel EtiquetaUsuario = new JLabel("Usuario :");
static TextField CajaTextoUsuario = new TextField(10);
JLabel EtiquetaNombreUsuario = new JLabel("Nombre usuario :");
static TextField CajaTextoNombreUsuario = new TextField(10);
JLabel EtiquetaCedulaUsuario = new JLabel("Cédula usuario :");
static TextField CajaTextoCedulaUsuario = new TextField(10);
JLabel EtiquetaNivel = new JLabel("Nivel :");
static String[] TipoUsuario = { "Administrador", "Estudiante" };
JComboBox ComboNivel = new JComboBox(TipoUsuario);
JLabel EtiquetaContrasena = new JLabel("Contraseña :");
static TextField CajaTextoContrasena = new TextField(10);
JLabel EtiquetaConfContrasena = new JLabel("Confirmar contraseña :");
static TextField CajaTextoConfContrasena = new TextField(10);
JButton BotonAceptarUsuario = new JButton("
JButton BotonCancelarUsuario = new JButton("
Aceptar
Cancelar
");
");
//*** Se define el método principal "main" de la Clase Usuarios
public static void main(String g[])
{
//*** Se ejecuta el constructor Usuarios de la clase Usuarios
Usuarios p = new Usuarios();
p.setVisible(true);
//*** Para cerrar la ventana
p.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
});
}
//*** Inicio del constructor Usuarios
Usuarios()
{
//*** Se define el título de la ventana
super(new Frame(), MenuAdministrador.nTituloUsuario, true);
//*** Se define el tamaño de la ventana para el diálogo
setBounds( 0, 0, 360, 310 );
//*** Se crean los páneles para acomodar los componentes
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
JPanel
PanelEspacioArriba = new JPanel();
PanelUsuario = new JPanel(new GridLayout(1,2));
PanelNombreUsuario = new JPanel(new GridLayout(1,2));
PanelCedulaUsuario = new JPanel(new GridLayout(1,2));
PanelNivel = new JPanel(new GridLayout(1,2));
PanelContrasena = new JPanel(new GridLayout(1,2));
PanelConfContrasena = new JPanel(new GridLayout(1,2));
Panel1 = new JPanel(new BorderLayout(5,10));
Panel2 = new JPanel(new BorderLayout(5,10));
PanelBotones = new JPanel(new GridLayout(1,2,30,3));
Panel3 = new JPanel(new BorderLayout(5,10));
Panel4 = new JPanel(new BorderLayout(5,10));
PanelPricipal = new JPanel(new FlowLayout(FlowLayout.CENTER));
//*** Etiquetas, cajas de texto y botones del diálogo
CajaTextoUsuario.setEditable(true);
CajaTextoNombreUsuario.setEditable(true);
CajaTextoCedulaUsuario.setEditable(true);
CajaTextoContrasena.setEditable(true);
CajaTextoConfContrasena.setEditable(true);
BotonAceptarUsuario.setText("
Aceptar
");
BotonAceptarUsuario.setMnemonic('A');
BotonAceptarUsuario.setToolTipText("Registrar usuario...");
if (MenuAdministrador.adsCedula.equals(""))
{
nIngresa = true;
CajaTextoUsuario.setText("");
CajaTextoNombreUsuario.setText("");
CajaTextoCedulaUsuario.setText("");
CajaTextoContrasena.setText("");
CajaTextoContrasena.setEchoChar('*');
CajaTextoConfContrasena.setText("");
CajaTextoConfContrasena.setEchoChar('*');
ComboNivel.setSelectedIndex(1);
}
else
{
nIngresa = false;
if (IntUsuarios.BuscarCedula(MenuAdministrador.adsCedula) == true)
{
if (MenuAdministrador.nMEU == false)
{
CajaTextoUsuario.setEditable(false);
CajaTextoNombreUsuario.setEditable(false);
CajaTextoCedulaUsuario.setEditable(false);
CajaTextoContrasena.setEditable(false);
CajaTextoConfContrasena.setEditable(false);
BotonAceptarUsuario.setText("
Eliminar
");
BotonAceptarUsuario.setMnemonic('E');
BotonAceptarUsuario.setToolTipText("Eliminar usuario...");
}
CajaTextoUsuario.setText(IntUsuarios.vUsuario);
CajaTextoNombreUsuario.setText(IntUsuarios.vNombre);
CajaTextoCedulaUsuario.setText(MenuAdministrador.adsCedula);
CajaTextoCedulaUsuario.setEditable(false);
CajaTextoContrasena.setText(IntUsuarios.vContrasena);
CajaTextoContrasena.setEchoChar('*');
CajaTextoConfContrasena.setText(IntUsuarios.vContrasena);
CajaTextoConfContrasena.setEchoChar('*');
ComboNivel.setSelectedIndex(IntUsuarios.vNivel);
}
}
BotonCancelarUsuario.setMnemonic('C');
BotonCancelarUsuario.setToolTipText("Cancelar y salir...");
PanelEspacioArriba.setLayout( new FlowLayout(FlowLayout.CENTER));
PanelUsuario.add(EtiquetaUsuario);
PanelUsuario.add(CajaTextoUsuario);
PanelNombreUsuario.add(EtiquetaNombreUsuario);
PanelNombreUsuario.add(CajaTextoNombreUsuario);
PanelCedulaUsuario.add(EtiquetaCedulaUsuario);
PanelCedulaUsuario.add(CajaTextoCedulaUsuario);
PanelNivel.add(EtiquetaNivel);
PanelNivel.add(ComboNivel);
PanelContrasena.add(EtiquetaContrasena);
PanelContrasena.add(CajaTextoContrasena);
PanelConfContrasena.add(EtiquetaConfContrasena);
PanelConfContrasena.add(CajaTextoConfContrasena);
Panel1.add(PanelEspacioArriba, BorderLayout.NORTH);
Panel1.add(PanelUsuario, BorderLayout.CENTER);
Panel1.add(PanelNombreUsuario, BorderLayout.SOUTH);
Panel2.add(PanelCedulaUsuario, BorderLayout.NORTH);
Panel2.add(PanelContrasena, BorderLayout.CENTER);
Panel2.add(PanelConfContrasena, BorderLayout.SOUTH);
PanelBotones.add(BotonAceptarUsuario);
PanelBotones.add(BotonCancelarUsuario);
Panel3.add(PanelNivel, BorderLayout.NORTH);
Panel3.add(PanelBotones, BorderLayout.SOUTH);
Panel4.add(Panel1, BorderLayout.NORTH);
Panel4.add(Panel2, BorderLayout.CENTER);
Panel4.add(Panel3, BorderLayout.SOUTH);
PanelPricipal.add(Panel4);
// *** Se agrega el panel principal al diálogo
getContentPane().add(PanelPricipal);
//*** Se desactiva maximizar/minimizar
setResizable(false);
// *** Se centra el diálogo en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
//*** Eventos producidos por los botones del diálogo
this.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
BotonAceptarUsuario.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
///*******************************
///*** VITAL
****
///*******************************
IntUsuarios.nControl2 = true;
ControlPassword.nControl1 = false;
ControlEstudiantes.nControl5 = false;
ControlHistorico.nControl7 = false;
ControlAsignaturas.nControl8 = false;
ControlInscripciones.nControl10 = false;
ControlValidaciones.nControl12 = false;
MenuAdministrador.nControl3 = false;
MenuAdministrador.nControl4 = false;
MenuAdministrador.nControl6 = false;
MenuAdministrador.nControl9 = false;
MenuAdministrador.nControl11 = false;
if (nIngresa == true)
{
//*** Se invocan los métodos IniciarVariables-VerificarDatos de la
//*** clase ControlUsuarios
UsuNivel = ComboNivel.getSelectedIndex();
IntUsuarios.IniciarVariables();
IntUsuarios.VerificarDatos();
MenuAdministrador.adsCedula = "";
}
else
{
if (MenuAdministrador.nMEU == true)
{
//*** Se invocan los métodos IniciarVariables-VerificarDatos de la
//*** clase ControlUsuarios
UsuNivel = ComboNivel.getSelectedIndex();
IntUsuarios.IniciarVariables();
IntUsuarios.VerificarDatos();
MenuAdministrador.adsCedula = "";
}
else
{
Toolkit.getDefaultToolkit().beep();
int n = JOptionPane.showConfirmDialog(null,"¿ Quiere eliminar este usuario ?",
"Eliminar...",JOptionPane.YES_NO_OPTION);
if (n == JOptionPane.YES_OPTION)
{
//*** Se invoca el método EliminarDatos de la clase ControlUsuarios
IntUsuarios.EliminarDatos(MenuAdministrador.adsCedula);
MenuAdministrador.adsCedula = "";
}
else
{
nUsu = true;
MenuAdministrador.adsCedula = "";
}
}
}
MenuAdministrador.nTituloUsuario = "Registrar usuario y contraseña";
if (nUsu == true)
{
nUsu = false;
CierraVentana();
}
}
});
BotonCancelarUsuario.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
MenuAdministrador.adsCedula = "";
MenuAdministrador.nTituloUsuario = "Registrar usuario y contraseña";
//*** Se ejecuta el método CierraVentana
CierraVentana();
}
});
}
//*** Fin del constructor Usuarios
//*** Se definen los métodos necesarios para abrir, cerrar las ventanas e
//*** iniciar etiquetas
public void actionPerformed(ActionEvent e)
{
Object s = e.getSource();
}
public void CierraVentana()
{
if (MenuAdministrador.nIMEU == true)
{
setVisible(false);
dispose();
}
else
{
setVisible( false );
dispose();
System.exit(0);
}
}
}
//***************************************************************************
// Fin Clase Usuarios
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: ControlPassword (Para trabajar con las
****
//**** funciones que hacen la comprobación de usuario y contraseña
****
//**** a la tabla USUARIOS de la base de datos ESTUDIANTES.MDB)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import java.io.*;
import java.sql.*;
//***************************************************************************
// Inicio Clase ControlPassword
//***************************************************************************
public class ControlPassword
{
//*** Se declaran las variables
static
static
static
static
static
static
static
static
String nUsuario;
String nUsuario2;
String nNombre;
int nCedula;
String nContrasena;
String nConfContrasena;
int nNivel;
String nDato;
static boolean nControl1 = true;
static String tuUsuario;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se define el método principal "main" de la Clase ControlPassword
public static void main(String[] args)
{
//*** Se coloca el método principal sólo como parte de la estructura de
//*** la clase, esta clase está compuesta por todos los métodos que hacen
//*** posible hacer la comprobación de usuario y contraseña en la
//*** tabla USUARIOS de la base de datos
}
//*** Se define el método IniciarVariables para iniciar las variables
public void IniciarVariables()
{
nUsuario = Password.CajaTextoInUsuario.getText();
nUsuario2 = Password.CajaTextoInUsuario.getText();
nContrasena = Password.CajaTextoInContrasena.getText();
nNombre = "";
nCedula = 0;
nNivel = 1;
nDato = "";
}
//*** Se define el método VerificarDatos para verificar usuario y contraseña
public void VerificarDatos()
{
if(!nUsuario.equals("") && !nContrasena.equals(""))
{
nNombre = NombreUsuario(nUsuario,nContrasena,nNombre);
nCedula = CedulaNivelUsuario(nUsuario,nContrasena,nCedula,nNivel,nDato = "ced");
nNivel = CedulaNivelUsuario(nUsuario,nContrasena,nCedula,nNivel,nDato = "niv");
if (!nNombre.equals("") && nCedula != 0)
{
if (nNivel == 0)
{
MenuAdministrador d = new MenuAdministrador();
ObtenerDatos(nNombre);
d.IniciarEtiquetas(nUsuario2,tuUsuario,nCedula);
d.setVisible(true);
Password.nPass = true;
MenuEstudiante.nControl3 = false;
MenuEstudiante.nControl4 = false;
MenuEstudiante.nControl6 = false;
MenuEstudiante.nControl9 = false;
MenuEstudiante.nControl11 = false;
}
else
{
MenuEstudiante d = new MenuEstudiante();
ObtenerDatos(nNombre);
d.IniciarEtiquetas(nUsuario2,tuUsuario,nCedula);
d.setVisible(true);
Password.nPass = true;
MenuAdministrador.nControl3 = false;
MenuAdministrador.nControl4 = false;
MenuAdministrador.nControl6 = false;
MenuAdministrador.nControl9 = false;
MenuAdministrador.nControl11 = false;
}
}
}
}
//*** Se define el método NombreUsuario para retornar el nombre completo del usuario
public String NombreUsuario(String MiUsuario,String MiContrasena,String MiNombre)
{
try
{
nConectaB = nConexion.HacerConexion();
int sw = 0;
while(sw == 0)
{
String sql = "SELECT * FROM USUARIOS WHERE NombreUsuario= '" + MiUsuario
+ "' AND ClaveUsuario= '" + MiContrasena + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
MiNombre = rs.getString("NombreCompleto");
}
if(sw == 0)
{
return MiNombre;
}
rs.close();
}
nConectaB.close();
return MiNombre;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
return MiNombre;
}
}
//*** Se define el método CedulaNivelUsuario para retornar la cédula del usuario
//*** y el nivel de acceso
public int CedulaNivelUsuario(String MiUsuario,String MiContrasena,
int MiCedula,int MiNivel,String MiDato)
{
try
{
nConectaB = nConexion.HacerConexion();
int sw = 0;
while(sw == 0)
{
String sql = "SELECT * FROM USUARIOS WHERE NombreUsuario= '"+ MiUsuario
+ "' AND ClaveUsuario= '" + MiContrasena + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
MiCedula = rs.getInt("CedulaUsuario");
MiNivel = rs.getInt("NivelUsuario");
}
if(sw == 0)
{
if (MiDato == "ced")
return MiCedula;
else
return MiNivel;
}
rs.close();
}
nConectaB.close();
if (MiDato == "ced")
return MiCedula;
else
return MiNivel;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
if (MiDato == "ced")
return MiCedula;
else
return MiNivel;
}
}
//*** Se define el método ObtenerDatos
public String ObtenerDatos(String MiDato)
{
tuUsuario = MiDato;
return tuUsuario;
}
}
//***************************************************************************
// Fin Clase ControlPassword
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: ControlAsignaturas (Para trabajar con todas ****
//**** las funciones que hacen transacciones a la tabla ASIGNATURAS de
****
//**** la base de datos ESTUDIANTES.MDB)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import java.io.*;
import java.sql.*;
//***************************************************************************
// Inicio Clase ControlAsignaturas
//***************************************************************************
public class ControlAsignaturas
{
//*** Se declaran las variables
static int vCodigo;
static String vNombre;
static String vUC;
static String vDato;
static String vCodigo2;
static boolean nRegistro = false;
static boolean nControl8 = true;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se define el método principal "main" de la Clase ControlAsignaturas
public static void main(String[] args)
{
//*** Se coloca el método principal sólo como parte de la estructura de
//*** la clase, esta clase está compuesta por todos los métodos que hacen
//*** posible hacer transacciones como: agregar, modificar, eliminar,
//*** etc.,en la tabla ASIGNATURAS de la base de datos
}
//*** Se define el método IniciarVariables para inicializar las variables
public void IniciarVariables()
{
vCodigo2 = Asignaturas.AsigCodH;
vNombre = Asignaturas.AsigNomH;
vUC = Asignaturas.AsigCreH;
}
//*** Se define el método VerificarDatos para verificar las asignaturas
public void VerificarDatos()
{
//*** Se registran los datos de las asignaturas a través del método GuardarDatos
if(!vCodigo2.equals("") && !vNombre.equals("") && !vUC.equals(""))
{
if (Asignaturas.nIngresa == true)
{
if (GuardarDatos(vCodigo2,vNombre,vUC) == true && nRegistro == false)
{
nRegistro = false;
Asignaturas.nAsig = true;
}
else
{
nRegistro = false;
Asignaturas.nAsig = false;
}
}
else
{
if (ActualizarDatos(vCodigo2,vNombre,vUC) == true && nRegistro == false)
{
nRegistro = false;
Asignaturas.nAsig = true;
}
else
{
nRegistro = false;
Asignaturas.nAsig = false;
}
}
}
}
//*** Se define el método GuardarDatos para guardar las asignaturas
public boolean GuardarDatos(String MiCodigo,String MiNombre,String MiUC)
{
try
{
if (ControlAsignaturas.nRegistro == false)
{
int cod = Integer.parseInt(MiCodigo);
int uc = Integer.parseInt(MiUC);
nConectaB = nConexion.HacerConexion();
String sql = "INSERT INTO ASIGNATURAS (CodigoAsignatura," +
"NombreAsignatura,UCAsignatura) " +
"VALUES ('"+cod+"', '"+MiNombre+"' , '"+uc+"');";
PreparedStatement ps=nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
System.out.println("Se han guardado los datos...");
Asignaturas.Fila[0] = MiCodigo;
Asignaturas.Fila[1] = MiNombre;
Asignaturas.Fila[2] = MiUC;
Asignaturas.MiTabla.addRow(Asignaturas.Fila);
}
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método ActualizarDatos para actualizar las asignaturas
public boolean ActualizarDatos(String MiCodigo,String MiNombre,String MiUC)
{
try
{
if (ControlAsignaturas.nRegistro == false)
{
int cod = Integer.parseInt(MiCodigo);
int uc = Integer.parseInt(MiUC);
nConectaB = nConexion.HacerConexion();
String sql = "UPDATE ASIGNATURAS SET CodigoAsignatura = '"+cod+"',NombreAsignatura =
'"+MiNombre+
"',UCAsignatura = '"+uc+"' WHERE Val(CodigoAsignatura)= '" + MiCodigo + "'";
PreparedStatement ps=nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
System.out.println("Se han actualizado los datos...");
Asignaturas.Fila[0] = MiCodigo;
Asignaturas.Tabla.setValueAt(Asignaturas.Fila[0],Asignaturas.Tabla.getSelectedRow(),0);
Asignaturas.Fila[1] = MiNombre;
Asignaturas.Tabla.setValueAt(Asignaturas.Fila[1],Asignaturas.Tabla.getSelectedRow(),1);
Asignaturas.Fila[2] = MiUC;
Asignaturas.Tabla.setValueAt(Asignaturas.Fila[2],Asignaturas.Tabla.getSelectedRow(),2);
}
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método EliminarDatos para eliminar la asignatura
public void EliminarDatos(String MiCodigo)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM ASIGNATURAS WHERE Val(CodigoAsignatura)= '" + MiCodigo + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
EliminarHistorico(MiCodigo);
System.out.println("Se han eliminado los datos...");
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
//*** Se define el método EliminarHistorico para eliminar la asignatura del histórico del
estudiante
public void EliminarHistorico(String MiHCodigo)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM HISTORICO WHERE Val(CodigoAsignatura)= '" + MiHCodigo + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
//*** Se define el método EliminarPensum para eliminar la asignatura del pensum de estudio
public void EliminarPensum(String MiHCodigo)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM PENSUM WHERE Val(CodigoAsignatura)= '" + MiHCodigo + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
}
//***************************************************************************
// Fin Clase ControlAsignaturas
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: ControlPensum (Para trabajar con todas
****
//**** las funciones que hacen transacciones a la tabla PENSUM de
****
//**** la base de datos ESTUDIANTES.MDB)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import java.io.*;
import java.sql.*;
//***************************************************************************
// Inicio Clase ControlPensum
//***************************************************************************
public class ControlPensum
{
//*** Se declaran las variables
static
static
static
static
static
static
static
String
String
String
String
String
String
String
vCodCa;
vCodAs;
vSem;
vPre1;
vPre2;
vPre3;
vPre4;
static String vNombreAsignatura;
static String vUC;
static boolean nRegistro = false;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se define el método principal "main" de la Clase ControlPensum
public static void main(String[] args)
{
//*** Se coloca el método principal sólo como parte de la estructura de
//*** la clase, esta clase está compuesta por todos los métodos que hacen
//*** posible hacer transacciones como: agregar, modificar, eliminar,
//*** en la tabla PENSUM de la base de datos
}
//*** Se define el método IniciarVariables para inicializar las variables
public void IniciarVariables()
{
vCodCa = Pensum.PenCodCa;
vCodAs = Pensum.PenCodAs;
vSem = Pensum.PenSem;
vPre1 = Pensum.PenPre1;
vPre2 = Pensum.PenPre2;
vPre3 = Pensum.PenPre3;
vPre4 = Pensum.PenPre4;
}
//*** Se define el método VerificarDatos para verificar los pensum
public void VerificarDatos()
{
//*** Se registran los datos de los pensum a través del método GuardarDatos
if (Pensum.nIngresa == true)
{
if (GuardarDatos(vCodCa,vCodAs,vSem,vPre1,vPre2,vPre3,vPre4) == true && nRegistro == false)
{
nRegistro = false;
Pensum.nPen = true;
}
else
{
nRegistro = false;
Pensum.nPen = false;
}
}
else
{
if (ActualizarDatos(vCodCa,vCodAs,vSem,vPre1,vPre2,vPre3,vPre4) == true && nRegistro ==
false)
{
nRegistro = false;
Pensum.nPen = true;
}
else
{
nRegistro = false;
Pensum.nPen = false;
}
}
}
//*** Se define el método GuardarDatos para guardar los pensum
public boolean GuardarDatos(String MiCarrera,String MiAsignatura,String MiSemestre,String MiPre1,
String MiPre2,String MiPre3,String MiPre4)
{
try
{
if (ControlPensum.nRegistro == false)
{
int car = Integer.parseInt(MiCarrera);
int asi = Integer.parseInt(MiAsignatura);
int sem = Integer.parseInt(MiSemestre);
int pr1 = Integer.parseInt(MiPre1);
int pr2 = Integer.parseInt(MiPre2);
int pr3 = Integer.parseInt(MiPre3);
int pr4 = Integer.parseInt(MiPre4);
nConectaB = nConexion.HacerConexion();
String sql = "INSERT INTO PENSUM (CodigoCarrera,CodigoAsignatura,SemestreAsignatura," +
"CodigoPreRequisito1,CodigoPreRequisito2,CodigoPreRequisito3,CodigoPreRequisito4) " +
"VALUES ('"+car+"', '"+asi+"', '"+sem+"', '"+pr1+"', '"+pr2+"',
'"+pr3+"','"+pr4+"');";
PreparedStatement ps=nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
System.out.println("Se han guardado los datos...");
TomarDatos1();
Pensum.Fila[0]
Pensum.Fila[1]
Pensum.Fila[2]
Pensum.Fila[3]
Pensum.Fila[4]
Pensum.Fila[5]
Pensum.Fila[6]
Pensum.Fila[7]
Pensum.Fila[8]
=
=
=
=
=
=
=
=
=
MiCarrera;
MiAsignatura;
vNombreAsignatura;
MiSemestre;
vUC;
MiPre1;
MiPre2;
MiPre3;
MiPre4;
Pensum.MiTabla.addRow(Pensum.Fila);
}
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método TomarDatos1 para buscar datos de asignaturas
public void TomarDatos1()
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM ASIGNATURAS WHERE Val(CodigoAsignatura)= '" + vCodAs + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
if(rs.getString("CodigoAsignatura").equals(vCodAs))
{
vNombreAsignatura = rs.getString("NombreAsignatura");
vUC = String.valueOf(rs.getInt("UCAsignatura"));
break;
}
}
rs.close();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
}
}
//*** Se define el método ActualizarDatos para actualizar los pensum
public boolean ActualizarDatos(String MiCarrera,String MiAsignatura,String MiSemestre,String
MiPre1,
String MiPre2,String MiPre3,String MiPre4)
{
try
{
if (ControlPensum.nRegistro == false)
{
int car = Integer.parseInt(MiCarrera);
int asi = Integer.parseInt(MiAsignatura);
int sem = Integer.parseInt(MiSemestre);
int pr1 = Integer.parseInt(MiPre1);
int pr2 = Integer.parseInt(MiPre2);
int pr3 = Integer.parseInt(MiPre3);
int pr4 = Integer.parseInt(MiPre4);
nConectaB = nConexion.HacerConexion();
String sql = "UPDATE PENSUM SET CodigoCarrera = '"+car+"',CodigoAsignatura = '"+asi+
"',SemestreAsignatura = '"+sem+"',CodigoPreRequisito1 = '"+pr1+
"',CodigoPreRequisito2 = '"+pr2+"',CodigoPreRequisito3 = '"+pr3+
"',CodigoPreRequisito4 = '"+pr4+"' WHERE Val(CodigoCarrera)= '" + MiCarrera +
"' AND Val(CodigoAsignatura)= '" + MiAsignatura + "'";
PreparedStatement ps=nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
System.out.println("Se han actualizado los datos...");
TomarDatos1();
Pensum.Fila[0] = MiCarrera;
Pensum.Tabla.setValueAt(Pensum.Fila[0],Pensum.Tabla.getSelectedRow(),0);
Pensum.Fila[1] = MiAsignatura;
Pensum.Tabla.setValueAt(Pensum.Fila[1],Pensum.Tabla.getSelectedRow(),1);
Pensum.Fila[2] = vNombreAsignatura;
Pensum.Tabla.setValueAt(Pensum.Fila[2],Pensum.Tabla.getSelectedRow(),2);
Pensum.Fila[3] = MiSemestre;
Pensum.Tabla.setValueAt(Pensum.Fila[3],Pensum.Tabla.getSelectedRow(),3);
Pensum.Fila[4] = vUC;
Pensum.Tabla.setValueAt(Pensum.Fila[4],Pensum.Tabla.getSelectedRow(),4);
Pensum.Fila[5] = MiPre1;
Pensum.Tabla.setValueAt(Pensum.Fila[5],Pensum.Tabla.getSelectedRow(),5);
Pensum.Fila[6] = MiPre2;
Pensum.Tabla.setValueAt(Pensum.Fila[6],Pensum.Tabla.getSelectedRow(),6);
Pensum.Fila[7] = MiPre3;
Pensum.Tabla.setValueAt(Pensum.Fila[7],Pensum.Tabla.getSelectedRow(),7);
Pensum.Fila[8] = MiPre4;
Pensum.Tabla.setValueAt(Pensum.Fila[8],Pensum.Tabla.getSelectedRow(),8);
}
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método EliminarDatos para eliminar asignaturas del pensum
public void EliminarDatos(String MiCarrera,String MiAsignatura)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM PENSUM WHERE Val(CodigoCarrera)= '" + MiCarrera + "'" +
" AND Val(CodigoAsignatura)= '" + MiAsignatura + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
System.out.println("Se han eliminado los datos...");
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
}
//***************************************************************************
// Fin Clase ControlPensum
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: ControlEstudiantes (Para trabajar con todas ****
//**** las funciones que hacen transacciones a la tabla ESTUDIANTES de
****
//**** la base de datos ESTUDIANTES.MDB)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import
import
import
import
import
import
java.io.*;
java.sql.*;
java.awt.*;
java.awt.event.*;
javax.swing.*;
javax.swing.table.DefaultTableModel;
//***************************************************************************
// Inicio Clase ControlEstudiantes
//***************************************************************************
public class ControlEstudiantes
{
//*** Se declaran las variables
static
static
static
static
static
static
static
static
static
static
static
static
static
static
int vCedula;
String vNombre;
int vDia;
int vMes;
int vAno;
int vSexo;
String vDireccion;
String vTelefono;
String vCorreo;
int vCarrera;
int vCentro;
String vDato;
String vCedula2;
boolean nRegistro = false;
static boolean nControl5 = true;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se define el método principal "main" de la Clase ControlEstudiantes
public static void main(String[] args)
{
//*** Se coloca el método principal sólo como parte de la estructura de
//*** la clase, esta clase está compuesta por todos los métodos que hacen
//*** posible hacer transacciones como: agregar, modificar, eliminar,
//*** buscar estudiantes,etc.,en la tabla ESTUDIANTES de la base de datos
}
//*** Se define el método IniciarVariables para inicializar las variables
public void IniciarVariables()
{
vCedula2 = Estudiantes.CajaTextoCedula.getText();
vNombre = Estudiantes.CajaTextoNombreEstudiante.getText();
vDia = Estudiantes.EstDia;
vMes = Estudiantes.EstMes;
vAno = Estudiantes.EstAno;
vSexo = Estudiantes.EstSex;
vDireccion = Estudiantes.CajaTextoDireccion.getText();
vTelefono = Estudiantes.CajaTextoTelefono.getText();
vCorreo = Estudiantes.CajaTextoCorreo.getText();
vCarrera = Estudiantes.EstCar;
vCentro = Estudiantes.EstCen;
}
//*** Se define el método VerificarDatos para verificar los datos del estudiante
public void VerificarDatos()
{
//*** Se registran los datos del estudiante a través del método GuardarDatos
if(!vCedula2.equals("") && !vNombre.equals("") && !vDireccion.equals(""))
{
if (Estudiantes.nIngresa == true)
{
if (GuardarDatos(vCedula2,vNombre,vDia,vMes,vAno,vSexo,vDireccion,vTelefono,
vCorreo,vCarrera,vCentro) == true && nRegistro == false)
{
nRegistro = false;
Estudiantes.nEst = true;
}
else
{
nRegistro = false;
Estudiantes.nEst = false;
}
}
else
{
if (ActualizarDatos(vCedula2,vNombre,vDia,vMes,vAno,vSexo,vDireccion,vTelefono,
vCorreo,vCarrera,vCentro) == true && nRegistro == false)
{
nRegistro = false;
Estudiantes.nEst = true;
}
else
{
nRegistro = false;
Estudiantes.nEst = false;
}
}
}
}
//*** Se define el método GuardarDatos para guardar los datos de estudiantes
public boolean GuardarDatos(String MiCedula,String MiMiNombre,int MiDia,int MiMes,int MiAno,
int MiSexo,String MiDireccion,String MiTelefono,String MiCorreo,
int MiCarrera,int MiCentro)
{
try
{
if (ControlEstudiantes.nRegistro == false)
{
int ced = Integer.parseInt(MiCedula);
MiDia = MiDia + 1;
MiMes = MiMes + 1;
MiAno = Integer.parseInt(Estudiantes.Ano[MiAno]);
String fecha = String.valueOf(MiDia + "/" + MiMes + "/" + MiAno);
String sexo = Estudiantes.Sexo[MiSexo];
if (MiCarrera == 0)
MiCarrera = 236;
if (MiCarrera == 1)
MiCarrera = 280;
if (MiCarrera == 2)
MiCarrera = 612;
if (MiCarrera == 3)
MiCarrera = 610;
String centro = Estudiantes.Centro[MiCentro];
nConectaB = nConexion.HacerConexion();
String sql = "INSERT INTO ESTUDIANTES (CedulaEstudiante, NombreEstudiante,
FechaNacimiento," +
"SexoEstudiante,DireccionEstudiante," +
"TelefonoEstudiante,CorreoEstudiante,CodigoCarrera,CentroLocal) " +
"VALUES ('"+ced+"', '"+MiMiNombre+"' , '"+fecha+"','"+sexo+"', '"
+MiDireccion+"', '"+MiTelefono+"', '"+MiCorreo+"',
'"+MiCarrera+"', '"+centro+"');";
PreparedStatement ps=nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
System.out.println("Se han guardado los datos...");
}
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método BuscarCedula para buscar datos de estudiantes
public boolean BuscarCedula(String MiCedula)
{
try
{
Integer.parseInt(MiCedula);
vNombre = "";
nConectaB = nConexion.HacerConexion();
int sw = 0;
while(sw == 0)
{
String sql = "SELECT * FROM ESTUDIANTES WHERE Val(CedulaEstudiante)= '" + MiCedula +
"'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
vNombre = rs.getString("NombreEstudiante");
String fecha = String.valueOf(rs.getString("FechaNacimiento"));
vDia = Integer.parseInt(fecha.substring(8, 10)) - 1;
vMes = Integer.parseInt(fecha.substring(5, 7)) - 1;
vAno = Integer.parseInt(fecha.substring(0, 4));
int Contador = 0;
for(int i = 1955; i < 1995; i ++)
{
if(i == vAno)
vAno = Contador;
Contador = Contador + 1;
}
String sexo = rs.getString("SexoEstudiante");
if (sexo.equals("Masculino"))
vSexo = 0;
else if (sexo.equals("Femenino"))
vSexo = 1;
vDireccion = rs.getString("DireccionEstudiante");
vTelefono = rs.getString("TelefonoEstudiante");
vCorreo = rs.getString("CorreoEstudiante");
vCarrera = rs.getInt("CodigoCarrera");
if (vCarrera == 236)
vCarrera = 0;
else if (vCarrera == 280)
vCarrera = 1;
else if (vCarrera == 612)
vCarrera = 2;
else if (vCarrera == 610)
vCarrera = 3;
String centro = rs.getString("CentroLocal");
if (centro.equals("Zona Central"))
vCentro = 0;
else if (centro.equals("Zona Occidental"))
vCentro = 1;
else if (centro.equals("Zona Oriental"))
vCentro = 2;
else if (centro.equals("Zona Sur"))
vCentro = 3;
}
if(sw == 0)
{
nConectaB.close();
return false;
}
rs.close();
}
nConectaB.close();
return true;
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método ActualizarDatos para actualizar los datos de estudiantes
public boolean ActualizarDatos(String MiCedula,String MiMiNombre,int MiDia,int MiMes,int MiAno,
int MiSexo,String MiDireccion,String MiTelefono,String MiCorreo,
int MiCarrera,int MiCentro)
{
try
{
if (ControlEstudiantes.nRegistro == false)
{
int ced = Integer.parseInt(MiCedula);
MiDia = MiDia + 1;
MiMes = MiMes + 1;
MiAno = Integer.parseInt(Estudiantes.Ano[MiAno]);
String fecha = String.valueOf(MiDia + "/" + MiMes + "/" + MiAno);
String sexo = Estudiantes.Sexo[MiSexo];
if (MiCarrera == 0)
MiCarrera = 236;
if (MiCarrera == 1)
MiCarrera = 280;
if (MiCarrera == 2)
MiCarrera = 612;
if (MiCarrera == 3)
MiCarrera = 610;
String centro = Estudiantes.Centro[MiCentro];
nConectaB = nConexion.HacerConexion();
String sql= "UPDATE ESTUDIANTES SET CedulaEstudiante = '"+ced+"',NombreEstudiante =
'"+MiMiNombre+
"',FechaNacimiento = '"+fecha+"',SexoEstudiante = '"+sexo+
"',DireccionEstudiante = '"+MiDireccion+"',TelefonoEstudiante =
'"+MiTelefono+"',CorreoEstudiante = '"+MiCorreo+
"',CodigoCarrera = '"+MiCarrera+"',CentroLocal = '"+centro+"' WHERE Val(CedulaEstudiante)
= '"+MiCedula+"'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
System.out.println("Se han actualizado los datos...");
}
return true;
}
catch(Exception e)
{
if (vDato == "Incorrecto")
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Este estudiante ya existe !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlEstudiantes.nRegistro = false;
}
else
{
System.out.println("Se ha producido un error : " + e.toString());
}
return false;
}
}
//*** Se define el método EliminarDatos para eliminar estudiantes
public void EliminarDatos(String MiCedula)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM ESTUDIANTES WHERE Val(CedulaEstudiante)= '" + MiCedula + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
EliminarHistorico(MiCedula);
EliminarInscripcion(MiCedula);
EliminarValidacion(MiCedula);
EliminarUsuario(MiCedula);
Estudiantes.nEst = true;
System.out.println("Se han eliminado los datos...");
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
//*** Se define el método EliminarHistorico para eliminar el histórico del estudiante
public void EliminarHistorico(String MiHCedula)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM HISTORICO WHERE Val(CedulaEstudiante)= '" + MiHCedula + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
//*** Se define el método EliminarInscripcion para eliminar la inscripción del estudiante
public void EliminarInscripcion(String MiHCedula)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM INSCRIPCIONES WHERE Val(CedulaEstudiante)= '" + MiHCedula +
"'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
//*** Se define el método EliminarValidacion para eliminar la validación del estudiante
public void EliminarValidacion(String MiHCedula)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM VALIDACIONES WHERE Val(CedulaEstudiante)= '" + MiHCedula + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
//*** Se define el método EliminarUsuario para eliminar el usuario del sistema
public void EliminarUsuario(String MiHCedula)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM USUARIOS WHERE Val(CedulaUsuario)= '" + MiHCedula + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
}
//*** Se crea una nueva clase para crear una tabla que sirve para consultar
//*** los datos de los estudiantes
class TablaEstudiantes extends JDialog
{
//*** Se declaran las variables
static int teCedula;
static String teNombre;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se crean los componentes necesarios
JButton
JButton
JButton
JButton
JButton
Boton1 = new
Boton2 = new
Boton3 = new
Boton4 = new
BotonAceptar
JButton("");
JButton("");
JButton("");
JButton("");
= new JButton(" Aceptar ");
public TablaEstudiantes()
{
//*** Se define el título y tamaño de la ventana
super(new Frame(), "Consultar estudiantes", true);
setBounds( 0, 0, 460, 310 );
//*** Se crean los páneles para acomodar los componentes
JPanel
JPanel
JPanel
JPanel
JPanel
PanelEspacio = new JPanel();
PanelTabla = new JPanel();
PanelBotonesTabla = new JPanel(new GridLayout(1,5,10,2));
Panel1Tabla = new JPanel(new BorderLayout(5,9));
PanelPricipalTabla = new JPanel(new FlowLayout(FlowLayout.CENTER));
DefaultTableModel MiTabla = new DefaultTableModel();
JTable Tabla = new JTable(MiTabla);
Tabla.setPreferredScrollableViewportSize(new Dimension(400,175));
JScrollPane scrollPane = new JScrollPane(Tabla);
MiTabla.addColumn("No. de cédula");
MiTabla.addColumn("Nombre del estudiante");
MiTabla.addColumn("Carrera");
//*** Se hace la conexión y se llena la tabla(listado) con los datos.
try
{
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM ESTUDIANTES ORDER BY CedulaEstudiante";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
//*** Se crea un arreglo que será una de las filas de la tabla.
Object [] Fila = new Object[3]; //*** Hay tres columnas en la tabla
String ced = String.valueOf(rs.getInt("CedulaEstudiante"));
Fila[0] = ced;
String nom = rs.getString("NombreEstudiante");
ObtenerDatos(nom);
Fila[1] = teNombre;
int car = rs.getInt("CodigoCarrera");
if (car == 236)
Fila[2] = "Ingeniería de Sistemas";
if (car == 280)
Fila[2] = "Ingeniería Industrial";
if (car == 612)
Fila[2] = "Administración de Empresas";
if (car == 610)
Fila[2] = "Contaduría Pública";
MiTabla.addRow(Fila);
}
rs.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
//*** Tooltips de los botones de la tabla
Boton1.setVisible(false);
Boton2.setVisible(false);
Boton3.setVisible(false);
Boton4.setVisible(false);
BotonAceptar.setMnemonic('A');
BotonAceptar.setToolTipText("Salir de la consulta...");
// *** Se agregan los componentes a los páneles
PanelEspacio.setLayout( new FlowLayout(FlowLayout.CENTER));
PanelTabla.add(scrollPane, BorderLayout.CENTER);
PanelBotonesTabla.add(Boton1);
PanelBotonesTabla.add(Boton2);
PanelBotonesTabla.add(BotonAceptar);
PanelBotonesTabla.add(Boton3);
PanelBotonesTabla.add(Boton4);
Panel1Tabla.add(PanelEspacio, BorderLayout.NORTH);
Panel1Tabla.add(PanelTabla, BorderLayout.CENTER);
Panel1Tabla.add(PanelBotonesTabla, BorderLayout.SOUTH);
PanelPricipalTabla.add(Panel1Tabla);
// *** Se agrega el panel principal a la ventana
add(PanelPricipalTabla);
//*** Se desactiva maximizar/minimizar
setResizable(false);
// *** Se centra la tabla en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
//*** Eventos producidos por los botones del diálogo
this.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
dispose();
}
});
BotonAceptar.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
dispose();
}
});
}
//*** Se define el método ObtenerDatos para cargar los datos a la tabla
public String ObtenerDatos(String MiDato)
{
teNombre = MiDato;
return teNombre;
}
}
//*** Fin de la clase TablaEstudiantes
//***************************************************************************
// Fin Clase ControlEstudiantes
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: ControlHistorico (Para trabajar con todas
****
//**** las funciones que hacen transacciones a la tabla HISTORICO de
****
//**** la base de datos ESTUDIANTES.MDB)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import java.io.*;
import java.sql.*;
//***************************************************************************
// Inicio Clase ControlHistorico
//***************************************************************************
public class ControlHistorico
{
//*** Se declaran las variables
static
static
static
static
static
static
static
int vCedula;
String vNombre;
int vCarrera;
int vCentro;
String vNombreAsignatura;
String vSemestre;
String vUC;
static
static
static
static
static
static
static
static
String CentroH;
String CarreraH;
String AsignaturaH;
String CalificacionH;
String LapsoH;
String vDato;
String vCedula2;
boolean nRegistro = false;
static boolean nControl7 = true;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se define el método principal "main" de la Clase ControlHistorico
public static void main(String[] args)
{
//*** Se coloca el método principal sólo como parte de la estructura de
//*** la clase, esta clase está compuesta por todos los métodos que hacen
//*** posible hacer transacciones como: agregar, modificar, eliminar,
//*** buscar calificaciones,etc.,en la tabla HISTORICO de la base de datos
}
//*** Se define el método IniciarVariables para inicializar las variables
public void IniciarVariables()
{
vCedula2 = Historico.CajaTextoCedula.getText();
AsignaturaH = Historico.HisAsiH;
CalificacionH = Historico.HisCalH;
LapsoH = Historico.HisLapH;
}
//*** Se define el método VerificarDatos para verificar las calificaciones del estudiante
public void VerificarDatos()
{
//*** Se registran los datos del histórico a través del método GuardarDatos
if (Historico.nIngresa == true)
{
if (GuardarDatos(vCedula2,AsignaturaH,CalificacionH,LapsoH) == true && nRegistro == false)
{
nRegistro = false;
Historico.nHis = true;
}
else
{
nRegistro = false;
Historico.nHis = false;
}
}
else
{
if (ActualizarDatos(vCedula2,AsignaturaH,CalificacionH,LapsoH) == true && nRegistro ==
false)
{
nRegistro = false;
Historico.nHis = true;
}
else
{
nRegistro = false;
Historico.nHis = false;
}
}
}
//*** Se define el método GuardarDatos para guardar las calificaciones del estudiante
public boolean GuardarDatos(String MiCedula,String MiAsignatura,String MiCalificacion,String
MiLapso)
{
try
{
if (ControlHistorico.nRegistro == false)
{
int ced = Integer.parseInt(MiCedula);
int car = Integer.parseInt(MiAsignatura);
int cal = Integer.parseInt(MiCalificacion);
nConectaB = nConexion.HacerConexion();
String sql = "INSERT INTO HISTORICO (CedulaEstudiante,CodigoAsignatura," +
"CalificacionAsignatura,LapsoAsignatura) " +
"VALUES ('"+ced+"', '"+car+"' , '"+cal+"', '"+MiLapso+"');";
PreparedStatement ps=nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
System.out.println("Se han guardado los datos...");
TomarDatos1();
TomarDatos2();
Historico.Fila[0]
Historico.Fila[1]
Historico.Fila[2]
Historico.Fila[3]
Historico.Fila[4]
Historico.Fila[5]
=
=
=
=
=
=
MiAsignatura;
vNombreAsignatura;
vSemestre;
vUC;
MiCalificacion;
MiLapso;
Historico.MiTabla.addRow(Historico.Fila);
}
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método TomarDatos1 para buscar datos de asignatura
public void TomarDatos1()
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM ASIGNATURAS WHERE Val(CodigoAsignatura)= '" + AsignaturaH +
"'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
if(rs.getString("CodigoAsignatura").equals(AsignaturaH))
{
vNombreAsignatura = rs.getString("NombreAsignatura");
vUC = String.valueOf(rs.getInt("UCAsignatura"));
break;
}
}
rs.close();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
}
}
//*** Se define el método TomarDatos2 para buscar datos de pensum
public void TomarDatos2()
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM PENSUM WHERE Val(CodigoAsignatura)= '" + AsignaturaH + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
if(rs.getString("CodigoAsignatura").equals(AsignaturaH))
{
vSemestre = String.valueOf(rs.getInt("SemestreAsignatura"));
break;
}
}
rs.close();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
}
}
//*** Se define el método BuscarCedula para buscar calificaciones de estudiantes
public boolean BuscarCedula(String MiCedula)
{
try
{
Integer.parseInt(MiCedula);
vNombre = "";
nConectaB = nConexion.HacerConexion();
int sw = 0;
while(sw == 0)
{
String sql = "SELECT * FROM ESTUDIANTES WHERE Val(CedulaEstudiante)= '" + MiCedula +
"'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
vNombre = rs.getString("NombreEstudiante");
vCarrera = rs.getInt("CodigoCarrera");
if (vCarrera == 236)
CarreraH = "Ingeniería de Sistemas (236)";
else if (vCarrera == 280)
CarreraH = "Ingeniería Industrial (280)";
else if (vCarrera == 612)
CarreraH = "Administración de Empresas (612)";
else if (vCarrera == 610)
CarreraH = "Contaduría Pública (610)";
CentroH = rs.getString("CentroLocal");
}
if(sw == 0)
{
nConectaB.close();
return false;
}
rs.close();
}
nConectaB.close();
return true;
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método ActualizarDatos para actualizar las calificaciones del estudiante
public boolean ActualizarDatos(String MiCedula,String MiAsignatura,String MiCalificacion,String
MiLapso)
{
try
{
if (ControlHistorico.nRegistro == false)
{
int ced = Integer.parseInt(MiCedula);
int car = Integer.parseInt(MiAsignatura);
int cal = Integer.parseInt(MiCalificacion);
nConectaB = nConexion.HacerConexion();
String sql = "UPDATE HISTORICO SET CedulaEstudiante = '"+ced+"',CodigoAsignatura =
'"+car+
"',CalificacionAsignatura = '"+cal+
"',LapsoAsignatura = '"+MiLapso+"' WHERE Val(CedulaEstudiante)= '" + MiCedula + "' AND "
+
"Val(CodigoAsignatura)= '" +
Historico.Tabla.getValueAt(Historico.Tabla.getSelectedRow(),0).toString() +
"' AND Val(CalificacionAsignatura)= '" +
Historico.Tabla.getValueAt(Historico.Tabla.getSelectedRow(),4).toString() +
"' AND " + "LapsoAsignatura= '" +
Historico.Tabla.getValueAt(Historico.Tabla.getSelectedRow(),5).toString() + "'";
PreparedStatement ps=nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
System.out.println("Se han actualizado los datos...");
TomarDatos1();
TomarDatos2();
Historico.Fila[0] = MiAsignatura;
Historico.Tabla.setValueAt(Historico.Fila[0],Historico.Tabla.getSelectedRow(),0);
Historico.Fila[1] = vNombreAsignatura;
Historico.Tabla.setValueAt(Historico.Fila[1],Historico.Tabla.getSelectedRow(),1);
Historico.Fila[2] = vSemestre;
Historico.Tabla.setValueAt(Historico.Fila[2],Historico.Tabla.getSelectedRow(),2);
Historico.Fila[3] = vUC;
Historico.Tabla.setValueAt(Historico.Fila[3],Historico.Tabla.getSelectedRow(),3);
Historico.Fila[4] = MiCalificacion;
Historico.Tabla.setValueAt(Historico.Fila[4],Historico.Tabla.getSelectedRow(),4);
Historico.Fila[5] = MiLapso;
Historico.Tabla.setValueAt(Historico.Fila[5],Historico.Tabla.getSelectedRow(),5);
}
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método EliminarDatos para eliminar calificaciones
public void EliminarDatos(String MiCedula,String MiAsignatura,String MiCalificacion,String
MiLapso)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM HISTORICO WHERE Val(CedulaEstudiante)= '" + MiCedula + "' AND "
+
"Val(CodigoAsignatura)= '" + MiAsignatura + "' AND Val(CalificacionAsignatura)= '" +
MiCalificacion + "' AND " +
"LapsoAsignatura= '" + MiLapso + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
System.out.println("Se han eliminado los datos...");
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
}
//***************************************************************************
// Fin Clase ControlHistorico
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: ControlInscripciones (Para trabajar con
****
//**** todas las funciones que hacen transacciones a la tabla
****
//**** INSCRIPCIONES de la base de datos ESTUDIANTES.MDB)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import java.io.*;
import java.sql.*;
//***************************************************************************
// Inicio Clase ControlInscripciones
//***************************************************************************
public class ControlInscripciones
{
//*** Se declaran las variables
static
static
static
static
static
static
static
static
int vCedula;
String vNombre;
String vCarrera;
String vCentro;
String vLapso;
String vDato;
String vCedula2;
int car = 0;
static boolean nRegistro = false;
static boolean nControl10 = true;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se define el método principal "main" de la Clase ControlInscripciones
public static void main(String[] args)
{
//*** Se coloca el método principal sólo como parte de la estructura de
//*** la clase, esta clase está compuesta por todos los métodos que hacen
//*** posible hacer transacciones como: agregar, modificar, eliminar,
//*** buscar estudiantes,etc.,en la tabla INSCRIPCIONES de la base de datos
}
//*** Se define el método IniciarVariables para inicializar las variables
public void IniciarVariables()
{
vCedula2 = Inscripciones.CajaTextoICedula.getText();
vNombre = Inscripciones.CajaTextoINombre.getText();
vCarrera = Inscripciones.CajaTextoICarrera.getText();
if (vCarrera.equals("Ingeniería de Sistemas (236)"))
vCarrera = "236";
if (vCarrera.equals("Ingeniería Industrial (280)"))
vCarrera = "280";
if (vCarrera.equals("Administración de Empresas (612)"))
vCarrera = "612";
if (vCarrera.equals("Contaduría Pública (610)"))
vCarrera = "610";
vLapso = Inscripciones.CajaTextoILapso.getText();
}
//*** Se define el método VerificarDatos para verificar los datos de las inscripciones
public void VerificarDatos()
{
//*** Se registran los datos de la inscripción a través del método GuardarDatos
if(!vCedula2.equals("") && !vCarrera.equals("") && !vNombre.equals("") && !vLapso.equals(""))
{
if (GuardarDatos(vCedula2,vCarrera,vLapso) == true && nRegistro == false)
{
nRegistro = false;
Inscripciones.nInc = true;
}
else
{
nRegistro = false;
Inscripciones.nInc = false;
}
}
}
//*** Se define el método GuardarDatos para guardar los datos la inscripción
public boolean GuardarDatos(String MiCedula, String MiCarrera, String MiLapso)
{
try
{
if (ControlInscripciones.nRegistro == false)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM INSCRIPCIONES WHERE Val(CedulaEstudiante) = '" + MiCedula
+ "'" +
" AND LapsoInscripcion = '" + MiLapso + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
for (int i=0; i<Inscripciones.MiTabla2.getRowCount(); i++)
{
int ced = Integer.parseInt(MiCedula);
int car = Integer.parseInt(MiCarrera);
int asi = Integer.parseInt(Inscripciones.MiTabla2.getValueAt(i,0).toString());
nConectaB = nConexion.HacerConexion();
String sql = "INSERT INTO INSCRIPCIONES (CedulaEstudiante,CodigoCarrera," +
"CodigoAsignatura,LapsoInscripcion) " +
"VALUES ('"+ced+"', '"+car+"' , '"+asi+"', '"+MiLapso+"');";
PreparedStatement ps=nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
System.out.println("Se han guardado los datos...");
}
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método BuscarCedula para buscar un estudiante por la cédula
public boolean BuscarCedula(String MiCedula)
{
try
{
Integer.parseInt(MiCedula);
vNombre = "";
nConectaB = nConexion.HacerConexion();
int sw = 0;
while(sw == 0)
{
String sql = "SELECT * FROM ESTUDIANTES WHERE Val(CedulaEstudiante) = '" + MiCedula +
"'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
vNombre = rs.getString("NombreEstudiante");
car = rs.getInt("CodigoCarrera");
if(car == 236)
vCarrera = "Ingeniería de Sistemas (236)";
if(car == 280)
vCarrera = "Ingeniería Industrial (280)";
if(car == 612)
vCarrera = "Administración de Empresas (612)";
if(car == 610)
vCarrera = "Contaduría Pública (610)";
vCentro = rs.getString("CentroLocal");
}
if(sw == 0)
{
nConectaB.close();
return false;
}
rs.close();
}
nConectaB.close();
return true;
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método BuscarCalificacion para buscar calificación aprobatoria
public boolean BuscarCalificacion(String MiCedula, int MiAsignatura)
{
try
{
nConectaB = nConexion.HacerConexion();
int sw = 0;
boolean nAprobada = false;
while(sw == 0)
{
String sql = "SELECT * FROM HISTORICO WHERE Val(CedulaEstudiante) = '" + MiCedula + "'"
+
" AND Val(CodigoAsignatura) = '" + MiAsignatura + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
int cal = rs.getInt("CalificacionAsignatura");
if(cal > 5)
nAprobada = true;
}
if(sw == 0)
{
return false;
}
rs.close();
}
nConectaB.close();
return true;
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
}
//***************************************************************************
// Fin Clase ControlInscripciones
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** validaciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: ControlValidaciones (Para trabajar con
****
//**** todas las funciones que hacen transacciones a la tabla
****
//**** VALIDACIONES de la base de datos ESTUDIANTES.MDB)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import
import
import
import
import
import
import
import
import
import
java.io.*;
java.sql.*;
java.awt.*;
java.awt.event.*;
javax.swing.*;
java.text.*;
java.util.Date;
javax.swing.table.DefaultTableModel;
java.awt.image.ImageObserver;
java.awt.Image;
//***************************************************************************
// Inicio Clase ControlValidaciones
//***************************************************************************
public class ControlValidaciones
{
//*** Se declaran las variables
static
static
static
static
static
static
static
static
static
static
static
static
static
static
int vCedula;
String vNombre;
String vCarrera;
String vCentro;
String vLapso;
String vBanco;
String vNumero;
String vDia;
String vMes;
String vAno;
String vMonto;
String vValida;
String vDato;
String vCedula2;
static
static
static
static
static
static
static
static
static
static
static
static
String nNombre;
String nCarrera;
String nCentro;
String nLapso;
String nBanco;
String nNumero;
String nDia;
String nMes;
String nAno;
String nMonto;
String nValida;
int car = 0;
static boolean nRegistro = false;
static boolean nControl12 = true;
Font
Font
Font
Font
fuente1
fuente2
fuente3
fuente4
=
=
=
=
new
new
new
new
Font("Arial",
Font("Arial",
Font("Arial",
Font("Arial",
PrintJob pj;
Graphics pagina;
ImageObserver observer;
String NbrImg;
Font.BOLD, 16);
Font.BOLD, 14);
Font.BOLD, 10);
Font.PLAIN, 10);
static int ValCedula = 0;
static int ValCreditos = 0;
static int ValArancel = 0;
NumberFormat nf1;
NumberFormat nf2;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se define el método principal "main" de la Clase ControlValidaciones
public static void main(String[] args)
{
//*** Se coloca el método principal sólo como parte de la estructura de
//*** la clase, esta clase está compuesta por todos los métodos que hacen
//*** posible hacer transacciones como: agregar, modificar, eliminar,
//*** buscar estudiantes,etc.,en la tabla VALIDACIONES de la base de datos
}
//*** Se define el método IniciarVariables para inicializar las variables
public void IniciarVariables()
{
vCedula2 = Validaciones.IntCed;
vLapso = Validaciones.IntLapso;
vBanco = Validaciones.IntBanco;
vNumero = Validaciones.IntNumero;
vDia = Validaciones.IntDia;
vMes = Validaciones.IntMes;
vAno = Validaciones.IntAno;
vMonto = Validaciones.IntMonto;
vValida = Validaciones.IntValida;
}
//*** Se define el método VerificarDatos para verificar los datos de las validaciones
public void VerificarDatos()
{
//*** Se registran los datos de la validación a través del método GuardarDatos
if(!vNumero.equals("") && !vMonto.equals("") &&
!vLapso.equals(""))
{
if (GuardarDatos(vCedula2,vLapso,vBanco,vNumero,vDia,vMes,vAno,vMonto,vValida) == true &&
nRegistro == false)
{
nRegistro = false;
Validaciones.nVal = true;
}
else
{
nRegistro = false;
Validaciones.nVal = false;
}
}
}
//*** Se define el método GuardarDatos para guardar los datos la validación
public boolean GuardarDatos(String MiCedula, String MiLapso, String MiBanco, String MiNumero,
String MiDia,
String MiMes, String MiAno, String MiMonto, String MiValida)
{
try
{
int ced = Integer.parseInt(MiCedula);
int num = Integer.parseInt(MiNumero);
String fecha = MiDia + "/" + MiMes + "/" + MiAno;
int mon = Integer.parseInt(MiMonto);
int val = Integer.parseInt(MiValida);
if (ControlValidaciones.nRegistro == false)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM VALIDACIONES WHERE Val(CedulaEstudiante) = '" + MiCedula
+ "'" +
" AND LapsoInscripcion = '" + MiLapso + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
nConectaB = nConexion.HacerConexion();
String sql = "INSERT INTO VALIDACIONES
(CedulaEstudiante,LapsoInscripcion,BancoDeposito," +
"NumeroDeposito,FechaDeposito,MontoDeposito,ValidacionInscripcion) " +
"VALUES ('"+ced+"', '"+MiLapso+"' , '"+MiBanco+"', '"+num+"', '"+fecha+"',
'"
+mon+"', '"+val+"');";
PreparedStatement ps=nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
System.out.println("Se han guardado los datos...");
}
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método BuscarCedula para buscar un estudiante por la cédula
public boolean BuscarCedula(String MiCedula)
{
try
{
Integer.parseInt(MiCedula);
nNombre = "";
nConectaB = nConexion.HacerConexion();
int sw = 0;
while(sw == 0)
{
String sql = "SELECT * FROM ESTUDIANTES WHERE Val(CedulaEstudiante) = '" + MiCedula +
"'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
nNombre = rs.getString("NombreEstudiante");
car = rs.getInt("CodigoCarrera");
if(car == 236)
nCarrera = "Ingeniería de Sistemas (236)";
if(car == 280)
nCarrera = "Ingeniería Industrial (280)";
if(car == 612)
nCarrera = "Administración de Empresas (612)";
if(car == 610)
nCarrera = "Contaduría Pública (610)";
nCentro = rs.getString("CentroLocal");
}
if(sw == 0)
{
nConectaB.close();
return false;
}
rs.close();
}
nConectaB.close();
return true;
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método BuscarRegistro para el registro de inscripción del estudiante
public boolean BuscarRegistro(String MiCedula, String MiLapso)
{
try
{
Integer.parseInt(MiCedula);
nConectaB = nConexion.HacerConexion();
int sw = 0;
while(sw == 0)
{
String sql = "SELECT * FROM VALIDACIONES WHERE Val(CedulaEstudiante) = '" + MiCedula +
"'" +
" AND LapsoInscripcion = '" + MiLapso + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
nBanco = rs.getString("BancoDeposito");
nNumero = String.valueOf(rs.getInt("NumeroDeposito"));
String fecha = String.valueOf(rs.getString("FechaDeposito"));
nDia = String.valueOf(Integer.parseInt(fecha.substring(8, 10)));
nMes = String.valueOf(Integer.parseInt(fecha.substring(5, 7)));
nAno = fecha.substring(0, 4);
nMonto = String.valueOf(rs.getInt("MontoDeposito"));
nValida = rs.getString("ValidacionInscripcion");
}
if(sw == 0)
{
nConectaB.close();
return false;
}
rs.close();
}
nConectaB.close();
return true;
}
catch (Exception e)
{
//System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se Se define el método ImprimePlanilla para imprimir la planilla de inscripción
public void ImprimePlanilla()
{
pj = Toolkit.getDefaultToolkit().getPrintJob(new Frame(), "Imprimir planilla de inscripción",
null);
//*** Para formato 1.000,00
nf1 = NumberFormat.getInstance();
nf1.setMinimumFractionDigits(0);
nf1.setMaximumFractionDigits(0);
nf2 = NumberFormat.getInstance();
nf2.setMinimumFractionDigits(2);
nf2.setMaximumFractionDigits(2);
try
{
pagina = pj.getGraphics();
pagina.setColor(Color.black);
Image L_Img = Toolkit.getDefaultToolkit().getImage("C:/TG-319/4-IMAGENES/UN-1.JPG");
pagina.drawImage(L_Img, 20, 160, 100, 100, Color.black, observer);
pagina.setFont(fuente1);
pagina.drawString("UNIVERSIDAD NACIONAL", 50, 60);
pagina.setFont(fuente2);
pagina.drawString("SECRETARÍA", 50, 75);
pagina.setFont(fuente4);
ValCedula = Integer.parseInt(Validaciones.CajaTextoVCedula.getText());
pagina.drawString("No. de cédula : " + nf1.format(ValCedula), 50, 120);
pagina.drawString("Centro local : " +
Validaciones.CajaTextoVCentro.getText().toUpperCase(), 200, 120);
pagina.drawString("Carrera : " + Validaciones.CajaTextoVCarrera.getText().toUpperCase(),
380, 120);
pagina.drawString("Nombre : " + Validaciones.CajaTextoVNombre.getText().toUpperCase(), 50,
140);
pagina.drawString("Lapso : " + Validaciones.CajaTextoVLapso.getText(), 380, 140);
pagina.setFont(fuente2);
pagina.drawString("INSCRIPCIÓN REGULAR LAPSO " + Validaciones.CajaTextoVLapso.getText(),
170, 180);
pagina.setFont(fuente3);
pagina.drawLine(50, 190, 570, 190);
pagina.drawString("CÓDIGO", 50, 205);
pagina.drawString("ASIGNATURA", 150, 205);
pagina.drawString("SEMESTRE", 300, 205);
pagina.drawString("U.C.", 420, 205);
pagina.drawString("ARANCEL", 500, 205);
pagina.drawLine(50, 210, 570, 210);
pagina.setFont(fuente4);
int Fila = 225;
for (int i=0; i<Validaciones.MiTabla1.getRowCount(); i++)
{
pagina.drawString(Validaciones.MiTabla1.getValueAt(i,0).toString(), 60, Fila);
if (Validaciones.MiTabla1.getValueAt(i,1).toString().length() > 30)
{
String Asignatura = Validaciones.MiTabla1.getValueAt(i,1).toString().substring(0,30);
pagina.drawString(Asignatura, 110, Fila);
}
else
{
pagina.drawString(Validaciones.MiTabla1.getValueAt(i,1).toString(), 110, Fila);
}
pagina.drawString(Validaciones.MiTabla1.getValueAt(i,2).toString(), 325, Fila);
pagina.drawString(Validaciones.MiTabla1.getValueAt(i,3).toString(), 425, Fila);
pagina.drawString(Validaciones.MiTabla1.getValueAt(i,4).toString(), 500, Fila);
Fila = Fila + 10;
}
pagina.drawLine(50, Fila, 570, Fila);
Fila = Fila + 20;
pagina.setFont(fuente3);
pagina.drawString("DEPÓSITOS REALIZADOS", 230, Fila);
Fila = Fila + 10;
pagina.drawLine(50, Fila, 570, Fila);
Fila = Fila + 15;
pagina.drawString("BANCO", 90, Fila);
pagina.drawString("NUM. DEP.", 260, Fila);
pagina.drawString("FECHA", 390, Fila);
pagina.drawString("MONTO", 500, Fila);
Fila = Fila + 5;
pagina.drawLine(50, Fila, 570, Fila);
Fila = Fila + 15;
pagina.setFont(fuente4);
pagina.drawString(Validaciones.IntBanco, 50, Fila);
pagina.drawString(Validaciones.CajaTextoNumDeposito.getText(), 260, Fila);
pagina.drawString(Validaciones.IntDia + "/" + Validaciones.IntMes + "/" +
Validaciones.IntAno, 385, Fila);
ValArancel = Integer.parseInt(Validaciones.CajaTextoMonDeposito.getText());
pagina.drawString(nf2.format(ValArancel), 500, Fila);
Fila = Fila + 10;
pagina.drawLine(50, Fila, 570, Fila);
Fila = Fila + 15;
pagina.setFont(fuente3);
pagina.drawString("ADMINISTRADOR", 70, Fila);
pagina.drawString("ESTUDIANTE", 260, Fila);
pagina.drawString("JEFE DE REGISTRO", 450, Fila);
Fila = Fila + 5;
pagina.drawLine(50, Fila, 570, Fila);
Fila = Fila + 50;
pagina.drawLine(50, Fila, 570, Fila);
pagina.dispose();
pj.end();
}
catch(Exception e)
{
System.out.println("Impresion cancelada...");
}
}
//*** Se define el método EliminarDatos para eliminar el registro de onscripción del estudiante
public void EliminarDatos(String MiCedula,String MiLapso)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM VALIDACIONES WHERE Val(CedulaEstudiante) = '" + MiCedula + "'"
+
" AND LapsoInscripcion = '" + MiLapso + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
}
//*** Se crea una nueva clase para crear una tabla que sirve para consultar
//*** las inscripciones que han sido validadas
class TablaValidaciones extends JDialog
{
//*** Se declaran las variables
static int teCedula;
static String teNombre;
String
String
String
String
String
Dia = "";
Mes = "";
Ano = "";
fecha = String.valueOf(new Date());
MiLapso;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se crean los componentes necesarios
JButton
JButton
JButton
JButton
JButton
Boton1 = new
Boton2 = new
Boton3 = new
Boton4 = new
BotonAceptar
JButton("");
JButton("");
JButton("");
JButton("");
= new JButton(" Aceptar ");
public TablaValidaciones()
{
//*** Se define el título y tamaño de la ventana
super(new Frame(), "Consultar validaciones de inscripción", true);
setBounds( 0, 0, 460, 310 );
//*** Se crean los páneles para acomodar los componentes
JPanel
JPanel
JPanel
JPanel
JPanel
PanelEspacio = new JPanel();
PanelTabla = new JPanel();
PanelBotonesTabla = new JPanel(new GridLayout(1,5,10,2));
Panel1Tabla = new JPanel(new BorderLayout(5,9));
PanelPricipalTabla = new JPanel(new FlowLayout(FlowLayout.CENTER));
DefaultTableModel MiTabla = new DefaultTableModel();
JTable Tabla = new JTable(MiTabla);
Tabla.setPreferredScrollableViewportSize(new Dimension(400,175));
JScrollPane scrollPane = new JScrollPane(Tabla);
Mes = fecha.substring(4,7);
Dia = fecha.substring(8,10);
Ano = fecha.substring(fecha.length() - 4, fecha.length());
if (Mes.equals("Jan") || Mes.equals("Feb") || Mes.equals("Mar") || Mes.equals("Apr") ||
Mes.equals("May") || Mes.equals("Jun"))
MiLapso = Ano + "-1";
else
MiLapso = Ano + "-2";
MiTabla.addColumn("No. de cédula");
MiTabla.addColumn("Nombre del estudiante");
MiTabla.addColumn("Carrera");
MiTabla.addColumn("Lapso");
//*** Se hace la conexión y se llena la tabla (listado) con los datos.
try
{
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM ESTUDIANTES a, VALIDACIONES b" +
" WHERE a.CedulaEstudiante = b.CedulaEstudiante AND b.LapsoInscripcion = '" + MiLapso + "'"
+
" AND b.ValidacionInscripcion = 1 ORDER BY a.CedulaEstudiante";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
//*** Se crea un arreglo que será una de las filas de la tabla.
Object [] Fila = new Object[4]; //*** Hay cuatro columnas en la tabla
String ced = String.valueOf(rs.getInt("CedulaEstudiante"));
Fila[0] = ced;
String nom = rs.getString("NombreEstudiante");
ObtenerDatos(nom);
Fila[1] = teNombre;
int car = rs.getInt("CodigoCarrera");
if (car == 236)
Fila[2] = "Ingeniería de Sistemas";
if (car == 280)
Fila[2] = "Ingeniería Industrial";
if (car == 612)
Fila[2] = "Administración de Empresas";
if (car == 610)
Fila[2] = "Contaduría Pública";
Fila[3] = rs.getString("LapsoInscripcion");
MiTabla.addRow(Fila);
}
rs.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
//*** Tooltips de los botones de la tabla
Boton1.setVisible(false);
Boton2.setVisible(false);
Boton3.setVisible(false);
Boton4.setVisible(false);
BotonAceptar.setMnemonic('A');
BotonAceptar.setToolTipText("Salir de la consulta...");
// *** Se agregan los componentes a los páneles
PanelEspacio.setLayout( new FlowLayout(FlowLayout.CENTER));
PanelTabla.add(scrollPane, BorderLayout.CENTER);
PanelBotonesTabla.add(Boton1);
PanelBotonesTabla.add(Boton2);
PanelBotonesTabla.add(BotonAceptar);
PanelBotonesTabla.add(Boton3);
PanelBotonesTabla.add(Boton4);
Panel1Tabla.add(PanelEspacio, BorderLayout.NORTH);
Panel1Tabla.add(PanelTabla, BorderLayout.CENTER);
Panel1Tabla.add(PanelBotonesTabla, BorderLayout.SOUTH);
PanelPricipalTabla.add(Panel1Tabla);
// *** Se agrega el panel principal a la ventana
add(PanelPricipalTabla);
//*** Se desactiva maximizar/minimizar
setResizable(false);
// *** Se centra la tabla en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
//*** Eventos producidos por los botones del diálogo
this.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
dispose();
}
});
BotonAceptar.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
dispose();
}
});
}
//*** Se define el método ObtenerDatos para cargar los datos a la tabla
public String ObtenerDatos(String MiDato)
{
teNombre = MiDato;
return teNombre;
}
}
//*** Fin de la clase TablaValidaciones
//***************************************************************************
// Fin Clase ControlValidaciones
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: ControlUsuarios (Para trabajar con todas
****
//**** las funciones que hacen transacciones a la tabla USUARIOS de
****
//**** la base de datos ESTUDIANTES.MDB)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import
import
import
import
import
import
java.io.*;
java.sql.*;
java.awt.*;
java.awt.event.*;
javax.swing.*;
javax.swing.table.DefaultTableModel;
//***************************************************************************
// Inicio Clase ControlUsuarios
//***************************************************************************
public class ControlUsuarios
{
//*** Se declaran las variables
static
static
static
static
static
static
static
static
static
String vUsuario;
String vNombre;
int vCedula;
String vContrasena;
String vConfContrasena;
int vNivel;
String vDato;
String vCedula2;
boolean nRegistro = false;
static boolean nControl2 = true;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se define el método principal "main" de la Clase ControlUsuarios
public static void main(String[] args)
{
//*** Se coloca el método principal sólo como parte de la estructura de
//*** la clase, esta clase está compuesta por todos los métodos que hacen
//*** posible hacer transacciones como: agregar, modificar, eliminar,
//*** buscar usuarios,etc.,en la tabla USUARIOS de la base de datos
}
//*** Se define el método IniciarVariables para inicializar las variables
public void IniciarVariables()
{
vUsuario = Usuarios.CajaTextoUsuario.getText();
vNombre = Usuarios.CajaTextoNombreUsuario.getText();
vCedula2 = Usuarios.CajaTextoCedulaUsuario.getText();
vContrasena = Usuarios.CajaTextoContrasena.getText();
vConfContrasena = Usuarios.CajaTextoConfContrasena.getText();
vNivel = Usuarios.UsuNivel;
}
//*** Se define el método VerificarDatos para verificar los datos del usuario
public void VerificarDatos()
{
//*** Se registran los datos del usuario a través del método GuardarDatos
if(!vUsuario.equals("") && !vNombre.equals("") &&
!vCedula2.equals("") && !vContrasena.equals("") &&
!vConfContrasena.equals("") && vContrasena.equals(vConfContrasena) &&
vUsuario.length() <= 14 && vContrasena.length() <= 8)
{
if (Usuarios.nIngresa == true)
{
if (GuardarDatos(vUsuario,vNombre,vCedula2,vContrasena,vNivel) == true && nRegistro ==
false)
{
nRegistro = false;
Usuarios.nUsu = true;
}
else
{
nRegistro = false;
Usuarios.nUsu = false;
}
}
else
{
if (ActualizarDatos(vUsuario,vNombre,vCedula2,vContrasena,vNivel) == true && nRegistro
== false)
{
nRegistro = false;
Usuarios.nUsu = true;
}
else
{
nRegistro = false;
Usuarios.nUsu = false;
}
}
}
}
//*** Se define el método GuardarDatos para guardar los datos de usuarios
public boolean GuardarDatos(String MiUsuario,String MiNombreUsuario,
String MiCedula,String MiContrasena,int MiNivel)
{
try
{
if (ControlUsuarios.nRegistro == false)
{
int ced = Integer.parseInt(MiCedula);
nConectaB = nConexion.HacerConexion();
String sql = "INSERT INTO USUARIOS (NombreUsuario, NombreCompleto, CedulaUsuario,
ClaveUsuario, NivelUsuario) " +
"VALUES ('"+MiUsuario+"', '"+MiNombreUsuario+"', '"+ced+"',
'"+MiContrasena+"','"+MiNivel+"');";
PreparedStatement ps=nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
System.out.println("Se han guardado los datos...");
}
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método BuscarCedula para buscar datos de usuarios
public boolean BuscarCedula(String MiCedula)
{
try
{
Integer.parseInt(MiCedula);
nConectaB = nConexion.HacerConexion();
int sw = 0;
while(sw == 0)
{
String sql = "SELECT * FROM USUARIOS WHERE Val(CedulaUsuario)= '" + MiCedula + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
vUsuario = rs.getString("NombreUsuario");
vNombre = rs.getString("NombreCompleto");
vCedula = rs.getInt("CedulaUsuario");
vContrasena = rs.getString("ClaveUsuario");
vNivel = rs.getInt("NivelUsuario");
}
if(sw == 0)
{
nConectaB.close();
return false;
}
rs.close();
}
nConectaB.close();
return true;
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método ActualizarDatos para actualizar los datos de usuarios
public boolean ActualizarDatos(String MiUsuario,String MiNombreUsuario,
String MiCedula,String MiContrasena,int MiNivel)
{
try
{
if (ControlUsuarios.nRegistro == false)
{
int ced = Integer.parseInt(MiCedula);
nConectaB = nConexion.HacerConexion();
String sql= "UPDATE USUARIOS SET NombreUsuario = '"+MiUsuario+"',NombreCompleto =
'"+MiNombreUsuario+
"',CedulaUsuario = '"+ced+"',ClaveUsuario = '"+MiContrasena+"',NivelUsuario = '"+MiNivel+
"' WHERE Val(CedulaUsuario) = '"+MiCedula+"'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
System.out.println("Se han actualizado los datos...");
}
return true;
}
catch(Exception e)
{
if (vDato == "Incorrecto")
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Este usuario o contraseña ya existe !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlUsuarios.nRegistro = false;
}
else
{
System.out.println("Se ha producido un error : " + e.toString());
}
return false;
}
}
//*** Se define el método EliminarDatos para eliminar usuarios
public void EliminarDatos(String MiCedula)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM USUARIOS WHERE Val(CedulaUsuario)= '" + MiCedula + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
EliminarEstudiante(MiCedula);
EliminarHistorico(MiCedula);
EliminarInscripcion(MiCedula);
EliminarValidacion(MiCedula);
Usuarios.nUsu = true;
System.out.println("Se han eliminado los datos...");
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
//*** Se define el método EliminarEstudiante para eliminar el estudiante del sistema
public void EliminarEstudiante(String MiHCedula)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM ESTUDIANTES WHERE Val(CedulaEstudiante)= '" + MiHCedula + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
//*** Se define el método EliminarHistorico para eliminar el histórico del estudiante
public void EliminarHistorico(String MiHCedula)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM HISTORICO WHERE Val(CedulaEstudiante)= '" + MiHCedula + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
//*** Se define el método EliminarInscripcion para eliminar la inscripción del estudiante
public void EliminarInscripcion(String MiHCedula)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM INSCRIPCIONES WHERE Val(CedulaEstudiante)= '" + MiHCedula +
"'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
//*** Se define el método EliminarValidacion para eliminar la validación del estudiante
public void EliminarValidacion(String MiHCedula)
{
try
{
nConectaB = nConexion.HacerConexion();
String sql = "DELETE * FROM VALIDACIONES WHERE Val(CedulaEstudiante)= '" + MiHCedula + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ps.executeUpdate();
nConectaB.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
}
}
//*** Se crea una nueva clase para crear una tabla que sirve para consultar
//*** los datos de los usuarios
class TablaUsuarios extends JDialog
{
//*** Se declaran las variables
static int tuCedula;
static String tuUsuario;
static String tuNombre;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
//*** Se crean los componentes necesarios
JButton
JButton
JButton
JButton
JButton
Boton1 = new
Boton2 = new
Boton3 = new
Boton4 = new
BotonAceptar
JButton("");
JButton("");
JButton("");
JButton("");
= new JButton(" Aceptar ");
public TablaUsuarios()
{
//*** Se define el título y tamaño de la ventana
super(new Frame(), "Consultar usuarios", true);
setBounds( 0, 0, 460, 310 );
//*** Se crean los páneles para acomodar los componentes
JPanel
JPanel
JPanel
JPanel
JPanel
PanelEspacio = new JPanel();
PanelTabla = new JPanel();
PanelBotonesTabla = new JPanel(new GridLayout(1,5,10,2));
Panel1Tabla = new JPanel(new BorderLayout(5,9));
PanelPricipalTabla = new JPanel(new FlowLayout(FlowLayout.CENTER));
DefaultTableModel MiTabla = new DefaultTableModel();
JTable Tabla = new JTable(MiTabla);
Tabla.setPreferredScrollableViewportSize(new Dimension(400,175));
JScrollPane scrollPane = new JScrollPane(Tabla);
MiTabla.addColumn("Usuario");
MiTabla.addColumn("Nombre de usuario");
MiTabla.addColumn("No. de cédula");
MiTabla.addColumn("Nivel");
//*** Se hace la conexión y se llena la tabla (listado) con los datos.
try
{
nConectaB = nConexion.HacerConexion();
String sql = "SELECT * FROM USUARIOS";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
//*** Se crea un arreglo que será una de las filas de la tabla.
Object [] Fila = new Object[4]; //*** Hay tres columnas en la tabla
String usu = rs.getString("NombreUsuario");
ObtenerDatos(usu);
Fila[0] = tuUsuario;
String nom = rs.getString("NombreCompleto");
ObtenerDatos(nom);
Fila[1] = tuUsuario;
String ced = String.valueOf(rs.getInt("CedulaUsuario"));
Fila[2] = ced;
int niv = rs.getInt("NivelUsuario");
if (niv == 0)
Fila[3] = "Administrador";
if (niv == 1)
Fila[3] = "Estudiante";
MiTabla.addRow(Fila);
}
rs.close();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : "+ e.toString());
}
//*** Tooltips de los botones de la tabla
Boton1.setVisible(false);
Boton2.setVisible(false);
Boton3.setVisible(false);
Boton4.setVisible(false);
BotonAceptar.setMnemonic('A');
BotonAceptar.setToolTipText("Salir de la consulta...");
// *** Se agregan los componentes a los páneles
PanelEspacio.setLayout( new FlowLayout(FlowLayout.CENTER));
PanelTabla.add(scrollPane, BorderLayout.CENTER);
PanelBotonesTabla.add(Boton1);
PanelBotonesTabla.add(Boton2);
PanelBotonesTabla.add(BotonAceptar);
PanelBotonesTabla.add(Boton3);
PanelBotonesTabla.add(Boton4);
Panel1Tabla.add(PanelEspacio, BorderLayout.NORTH);
Panel1Tabla.add(PanelTabla, BorderLayout.CENTER);
Panel1Tabla.add(PanelBotonesTabla, BorderLayout.SOUTH);
PanelPricipalTabla.add(Panel1Tabla);
// *** Se agrega el panel principal a la ventana
add(PanelPricipalTabla);
//*** Se desactiva maximizar/minimizar
setResizable(false);
// *** Se centra la tabla en la pantalla
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();
this.setLocation(((pantalla.width - cuadro.width)/2), (pantalla.height - cuadro.height)/2);
//*** Eventos producidos por los botones del diálogo
this.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
dispose();
}
});
BotonAceptar.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
dispose();
}
});
}
//*** Se define el método ObtenerDatos para cargar los datos a la tabla
public String ObtenerDatos(String MiDato)
{
tuUsuario = MiDato;
return tuUsuario;
}
}
//*** Fin de la clase TablaUsuarios
//***************************************************************************
// Fin Clase ControlUsuarios
//***************************************************************************
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** CÓDIGO BASE - CLASE: ConexionODBC (Carga el driver y hace la
****
//**** conexión con el origen de datos "Estudiantes" a través de un
****
//**** puente JDBC-ODBC)
****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import java.sql.*;
//***************************************************************************
// Inicio Clase ConexionODBC
//***************************************************************************
public class ConexionODBC
{
//*** Se define el método principal "main" de la Clase ConexionODBC
public static void main(String[] args)
{
//*** Se ejecuta el constructor ConexionODBC de la clase ConexionODBC,
//*** esta clase simplemente carga el driver JDBC y hace la conexión con
//*** el origen de datos "Estudiantes" a través de un puente JDBC-ODBC,
//*** para más información sobre el origen de datos consultar el archivo
//*** C:\TG-319\3-BASE DE DATOS\ACERCA DEL ORIGEN DE DATOS.doc
new ConexionODBC();
}
//*** Se define el constructor ConexionODBC para cargar el driver
//*** "sun.jdbc.odbc.JdbcOdbcDriver"
ConexionODBC()
{
try
{
Driver d = (Driver)Class.forName("sun.jdbc.odbc.JdbcOdbcDriver").newInstance();
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
}
}
//*** Se define el método HacerConexion para crear la conexión con el origen
//*** de datos "Estudiantes"
public Connection HacerConexion()
{
Connection nConecta = null;
try
{
nConecta = DriverManager.getConnection("jdbc:odbc:Estudiantes","","");
}
catch (Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
}
return nConecta;
}
}
//***************************************************************************
// Fin Clase ConexionODBC
//***************************************************************************
ANEXO 5
DOCUMENTACIÓN DEL ASPECTO
//***************************************************************************
//**** UNIVERSIDAD NACIONAL ABIERTA
****
//**** CENTRO LOCAL SUCRE - 17
****
//**** INGENIERÍA DE SISTEMAS - 236
****
//****
****
//**** TRABAJO DE GRADO - 319
****
//**** LAPSO: 2006-2
****
//**** IMPLEMENTACIÓN DE REQUISITOS NO FUNCIONALES A TRAVÉS DE LA
****
//**** PROGRAMACIÓN ORIENTADA A ASPECTOS
****
//****
****
//**** CASO DE ESTUDIO: Aplicación que simula el registro de
****
//**** inscripciones regulares de una universidad (UNSIR 1.0.1)
****
//****
****
//**** ASPECTO: AspectoSeguridad (Para crear el aspecto SEGURIDAD con
****
//**** los atributos: Integridad, Disponibilidad y Confidencialidad,
****
//**** como requisitos no funcionales común para las clases de control) ****
//****
****
//**** AUTOR: CARLOS CÓRDOVA - C.I.: 8.441.858
****
//***************************************************************************
//***************************************************************************
// Paquetes de la librería de clases estándar de Java
//***************************************************************************
import
import
import
import
java.awt.*;
javax.swing.*;
java.io.*;
java.sql.*;
//***************************************************************************
// Inicio Aspecto AspectoSeguridad
//***************************************************************************
public aspect AspectoSeguridad
{
//*** Se declaran las variables
static
static
static
static
static
static
String SeUsuario;
String SeNombre;
String SeCedula;
String SeContrasena;
String SeConfContrasena;
int SeNivel;
static String SeCaracter;
static String SeCodigo;
static int Img = 0;
//*** Se declara una variable y se crean dos objetos para gestionar el manejo
//*** del origen de datos de la clase ConexionODBC
InputStream nInp = System.in;
InputStreamReader nControl = new InputStreamReader(nInp);
BufferedReader nBuffer = new BufferedReader(nControl);
//*** Se crea una instancia nConexion de la clase ConexionODBC para utilizar
//*** los métodos de esta clase, que hacen el puente JDBC-ODBC
ConexionODBC nConexion = new ConexionODBC();
Connection nConectaB = null;
///************************************************************************
///*** ASPECTO: SEGURIDAD - ATRIBUTO: INTEGRIDAD
///*** POINCUT: MANEJO DE EXCEPCIONES
///************************************************************************
///************************************************************************
///*** POINTCUT Excepciones atraviesa ortogonalmente a las clases:
///*** ControlPassword,ControlUsuarios,ControlEstudiantes,ControlAsignaturas,
///*** ControlInscripciones,ControlValidaciones en los métodos
///*** VerificarDatos(),BuscarCedula
///************************************************************************
pointcut Excepciones(): (execution(*
execution(*
execution(*
execution(*
execution(*
execution(*
execution(*
execution(*
execution(*
ControlPassword.VerificarDatos(..)) ||
ControlUsuarios.VerificarDatos(..)) ||
ControlEstudiantes.VerificarDatos(..))||
ControlAsignaturas.VerificarDatos(..))||
ControlInscripciones.VerificarDatos(..))||
ControlValidaciones.VerificarDatos(..))||
ControlUsuarios.BuscarCedula(..))||
ControlEstudiantes.BuscarCedula(..))||
ControlHistorico.BuscarCedula(..))||
execution(* ControlInscripciones.BuscarCedula(..))||
execution(* ControlValidaciones.BuscarCedula(..)));
///************************************************************************
///*** Advise before: pointcut Excepciones()
///************************************************************************
before (): Excepciones()
{
if (ControlPassword.nControl1 == true)
{
//*** Muestra mensajes de advertencia en caso de que los datos no sean
//*** correctos o cuando no se encuentra un usuario/contraseña a través
//*** de la clase ControlPassword y así mantener la integridad de los datos
if(ControlPassword.nUsuario.equals("") && ControlPassword.nContrasena.equals(""))
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe llenar los campos de Usuario y Contraseña !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlPassword.nUsuario = "";
}
else if (BuscarUsuario(ControlPassword.nUsuario,ControlPassword.nContrasena)== false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Este usuario o contraseña no existe !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlPassword.nUsuario = "";
}
}
if (ControlUsuarios.nControl2 == true)
{
//*** Muestra mensajes de advertencia en caso de que los datos no sean
//*** correctos cuando se quiere ingresar un usuario nuevo a través
//*** de la clase ControlUsuarios y así mantener la integridad de los datos
if(!ControlUsuarios.vUsuario.equals("") && !ControlUsuarios.vNombre.equals("") &&
!ControlUsuarios.vCedula2.equals("") && !ControlUsuarios.vContrasena.equals("") &&
!ControlUsuarios.vConfContrasena.equals(""))
{
if (ControlUsuarios.vUsuario.length() > 14)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ El nombre del usuario debe tener máximo 14 carecteres !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlUsuarios.vCedula2 = "";
}
else if (ControlUsuarios.vContrasena.length() > 8)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ La contraseña del usuario debe tener máximo 8 carecteres !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlUsuarios.vCedula2 = "";
}
else if (ValidarCedula(ControlUsuarios.vCedula2) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe ingresar una valor numérico para la cédula !!","Atención",
JOptionPane.ERROR_MESSAGE);
ControlUsuarios.vCedula2 = "";
}
else if (!ControlUsuarios.vContrasena.equals(ControlUsuarios.vConfContrasena))
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Verifique la confirmación de la contraseña !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlUsuarios.vCedula2 = "";
}
else if (ExisteUsuario(ControlUsuarios.vUsuario,ControlUsuarios.vContrasena) == true)
{
if(Usuarios.nIngresa == true)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Este usuario o contraseña ya existe !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlUsuarios.vCedula2 = "";
}
}
else if (ExisteCedulaUsuario(ControlUsuarios.vCedula2) == true)
{
if(Usuarios.nIngresa == true)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Ya existe un usuario con este número de cédula !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlUsuarios.vCedula2 = "";
}
}
else
{
ControlUsuarios.nRegistro = true;
MenuAdministrador.nMEU = true;
}
}
else
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe llenar todos los campos obligatoriamente !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlUsuarios.nRegistro = false;
}
}
if (ControlEstudiantes.nControl5 == true)
{
//*** Muestra mensajes de advertencia en caso de que los datos no sean
//*** correctos cuando se quiere ingresar un estudiante nuevo a través
//*** de la clase ControlEstudiantes y así mantener la integridad de los datos
if(!ControlEstudiantes.vCedula2.equals("") && !ControlEstudiantes.vNombre.equals("") &&
!ControlEstudiantes.vDireccion.equals(""))
{
if (ValidarCedula(ControlEstudiantes.vCedula2) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe ingresar una valor numérico para la cédula !!","Atención",
JOptionPane.ERROR_MESSAGE);
ControlEstudiantes.vCedula2 = "";
}
else if (((ControlEstudiantes.vDia + 1) == 29 && (ControlEstudiantes.vMes + 1) == 2 &&
!Estudiantes.Ano[ControlEstudiantes.vAno].equals("1956") &&
!Estudiantes.Ano[ControlEstudiantes.vAno].equals("1960") &&
!Estudiantes.Ano[ControlEstudiantes.vAno].equals("1964") &&
!Estudiantes.Ano[ControlEstudiantes.vAno].equals("1968") &&
!Estudiantes.Ano[ControlEstudiantes.vAno].equals("1972") &&
!Estudiantes.Ano[ControlEstudiantes.vAno].equals("1976") &&
!Estudiantes.Ano[ControlEstudiantes.vAno].equals("1980") &&
!Estudiantes.Ano[ControlEstudiantes.vAno].equals("1984") &&
!Estudiantes.Ano[ControlEstudiantes.vAno].equals("1988") &&
!Estudiantes.Ano[ControlEstudiantes.vAno].equals("1992")) ||
((ControlEstudiantes.vDia + 1) >= 30 && (ControlEstudiantes.vMes + 1) == 2) ||
((ControlEstudiantes.vDia + 1) == 31 && (ControlEstudiantes.vMes + 1) == 4) ||
((ControlEstudiantes.vDia + 1) == 31 && (ControlEstudiantes.vMes + 1) == 6) ||
((ControlEstudiantes.vDia + 1) == 31 && (ControlEstudiantes.vMes + 1) == 9) ||
((ControlEstudiantes.vDia + 1) == 31 && (ControlEstudiantes.vMes + 1) == 11))
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe ingresar una fecha correcta para este año !!","Atención",
JOptionPane.ERROR_MESSAGE);
ControlEstudiantes.vCedula2 = "";
}
else if (ExisteCedulaEstudiante(ControlEstudiantes.vCedula2) == true)
{
if(Estudiantes.nIngresa == true)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Ya existe un estudiante con este número de cédula !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlEstudiantes.vCedula2 = "";
}
else
{
ControlEstudiantes.nRegistro = true;
MenuAdministrador.nMEU = true;
}
}
else
{
ControlEstudiantes.nRegistro = true;
MenuAdministrador.nMEU = true;
}
}
else
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe llenar los campos cédula, nombre y dirección obligatoriamente !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlEstudiantes.nRegistro = false;
}
}
if (ControlAsignaturas.nControl8 == true)
{
//*** Muestra mensajes de advertencia en caso de que los datos no sean
//*** correctos cuando se quiere ingresar una asignatura nueva a través
//*** de la clase ControlAsignaturas y así mantener la integridad de los datos
if(!ControlAsignaturas.vCodigo2.equals("") && !ControlAsignaturas.vNombre.equals("") &&
!ControlAsignaturas.vUC.equals(""))
{
if (ValidarCodigo(ControlAsignaturas.vCodigo2) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe ingresar una valor numérico para el código !!","Atención",
JOptionPane.ERROR_MESSAGE);
ControlAsignaturas.nRegistro = false;
MenuAdministrador.nMEU = false;
}
else if (ExisteCodigoAsignatura(ControlAsignaturas.vCodigo2) == true)
{
if(Asignaturas.nIngresa == true)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Ya existe una asignatura con este número de código !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlAsignaturas.nRegistro = false;
MenuAdministrador.nMEU = false;
}
}
else
MenuAdministrador.nMEU = true;
}
else
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe llenar todos los campos obligatoriamente !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlAsignaturas.nRegistro = false;
}
}
if (ControlValidaciones.nControl12 == true && MenuEstudiante.adsCedula.equals(""))
{
//*** Muestra mensajes de advertencia en caso de que los datos no sean
//*** correctos cuando se quiere ingresar una asignatura nueva a través
//*** de la clase ControlValidaciones y así mantener la integridad de los datos
if(!ControlValidaciones.vNumero.equals("") && !ControlValidaciones.vMonto.equals(""))
{
if (ValidarCodigo(ControlValidaciones.vNumero) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe ingresar una valor numérico para el número de depósito !!","Atención",
JOptionPane.ERROR_MESSAGE);
ControlValidaciones.nRegistro = false;
MenuAdministrador.nMEU = false;
}
else if (ValidarCodigo(ControlValidaciones.vMonto) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe ingresar una valor numérico para el monto !!","Atención",
JOptionPane.ERROR_MESSAGE);
ControlValidaciones.nRegistro = false;
MenuAdministrador.nMEU = false;
}
else if ((ControlValidaciones.vDia.equals("29") && ControlValidaciones.vMes.equals("2")
&&
!ControlValidaciones.vAno.equals("1976") &&
!ControlValidaciones.vAno.equals("1980") &&
!ControlValidaciones.vAno.equals("1984") &&
!ControlValidaciones.vAno.equals("1988") &&
!ControlValidaciones.vAno.equals("1992") &&
!ControlValidaciones.vAno.equals("1996") &&
!ControlValidaciones.vAno.equals("2000") &&
!ControlValidaciones.vAno.equals("2004") &&
!ControlValidaciones.vAno.equals("2008") &&
!ControlValidaciones.vAno.equals("2012")) ||
((ControlValidaciones.vDia.equals("30") ||
ControlValidaciones.vDia.equals("31")) &&
(ControlValidaciones.vMes.equals("2"))) ||
(ControlValidaciones.vDia.equals("31") &&
ControlValidaciones.vMes.equals("4")) ||
(ControlValidaciones.vDia.equals("31") &&
ControlValidaciones.vMes.equals("6")) ||
(ControlValidaciones.vDia.equals("31") &&
ControlValidaciones.vMes.equals("9")) ||
(ControlValidaciones.vDia.equals("31") &&
ControlValidaciones.vMes.equals("11")))
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe ingresar una fecha correcta para este año !!","Atención",
JOptionPane.ERROR_MESSAGE);
ControlValidaciones.vMonto = "";
ControlValidaciones.nRegistro = false;
MenuAdministrador.nMEU = false;
}
else
MenuAdministrador.nMEU = true;
}
else
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe llenar todos los campos obligatoriamente !!","Atención",
JOptionPane.WARNING_MESSAGE);
ControlValidaciones.nRegistro = false;
}
}
//*** Muestra mensajes de advertencia en caso de que los datos no sean
//*** correctos cuando se quiere ingresar un número de cédula
//*** y así mantener la integridad de los datos a través de las clases
//*** de control
if (MenuAdministrador.nControl3 == true)
{
if (ValidarCedula(MenuAdministrador.adsCedula) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe ingresar una valor numérico para la cédula !!","Atención",
JOptionPane.ERROR_MESSAGE);
MenuAdministrador.nControl3 = false;
}
else if (ExisteCedulaUsuario(MenuAdministrador.adsCedula) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ No existe un usuario con este número de cédula !!","Atención",
JOptionPane.WARNING_MESSAGE);
MenuAdministrador.nControl3 = false;
}
}
if (MenuAdministrador.nControl4 == true)
{
if (ValidarCedula(MenuAdministrador.adsCedula) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe ingresar una valor numérico para la cédula !!","Atención",
JOptionPane.ERROR_MESSAGE);
MenuAdministrador.nControl4 = false;
MenuAdministrador.adsCedula = "";
}
else if (ExisteCedulaEstudiante(MenuAdministrador.adsCedula) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ No existe un estudiante con este número de cédula !!","Atención",
JOptionPane.WARNING_MESSAGE);
MenuAdministrador.nControl4 = false;
MenuAdministrador.adsCedula = "";
}
}
if (MenuAdministrador.nControl6 == true)
{
if (ValidarCedula(MenuAdministrador.adsCedula2) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe ingresar una valor numérico para la cédula !!","Atención",
JOptionPane.ERROR_MESSAGE);
MenuAdministrador.nControl6 = false;
MenuAdministrador.adsCedula2 = "";
}
else if (ExisteCedulaEstudiante(MenuAdministrador.adsCedula2) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ No existe un estudiante con este número de cédula !!","Atención",
JOptionPane.WARNING_MESSAGE);
MenuAdministrador.nControl6 = false;
MenuAdministrador.adsCedula2 = "";
}
else
ControlHistorico.nRegistro = true;
}
if (MenuAdministrador.nControl9 == true)
{
if (ValidarCedula(MenuAdministrador.adsCedula3) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe ingresar una valor numérico para la cédula !!","Atención",
JOptionPane.ERROR_MESSAGE);
MenuAdministrador.nControl9 = false;
}
else if (ExisteCedulaEstudiante(MenuAdministrador.adsCedula3) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ No existe un estudiante con este número de cédula !!","Atención",
JOptionPane.WARNING_MESSAGE);
MenuAdministrador.nControl9 = false;
}
else
ControlInscripciones.nRegistro = true;
}
if (MenuAdministrador.nControl11 == true)
{
if (ValidarCedula(MenuAdministrador.adsCedula4) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Debe ingresar una valor numérico para la cédula !!","Atención",
JOptionPane.ERROR_MESSAGE);
MenuAdministrador.nControl11 = false;
}
else if (ExisteCedulaEstudiante(MenuAdministrador.adsCedula4) == false)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ No existe un estudiante con este número de cédula !!","Atención",
JOptionPane.WARNING_MESSAGE);
MenuAdministrador.nControl11 = false;
}
else
ControlValidaciones.nRegistro = true;
}
}
///************************************************************************
///*** Advise after: pointcut Excepciones()
///************************************************************************
after(): Excepciones()
{
//*** Muestra mensaje de transacción exitosa en caso de que los datos
//*** ingresados a través de las clases de control sean correctos
if (ControlUsuarios.nControl2 == true)
{
if (Usuarios.nUsu == true)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Los datos del usuario fueron guardados con éxito !!","Atención",
JOptionPane.INFORMATION_MESSAGE);
}
}
if (ControlEstudiantes.nControl5 == true)
{
if (Estudiantes.nEst == true)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Los datos del estudiante fueron guardados con éxito !!","Atención",
JOptionPane.INFORMATION_MESSAGE);
}
}
if (ControlHistorico.nControl7 == true)
{
if (Historico.nHis == true)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Los datos del histórico del estudiante fueron guardados con éxito !!","Atención",
JOptionPane.INFORMATION_MESSAGE);
}
}
if (ControlAsignaturas.nControl8 == true)
{
if (Asignaturas.nAsig == true)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Los datos de la materia fueron guardados con éxito !!","Atención",
JOptionPane.INFORMATION_MESSAGE);
}
}
if (ControlInscripciones.nControl10 == true)
{
if (Inscripciones.nInc == true)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Los datos de la selección de asignaturas fueron guardados con éxito !!","Atención",
JOptionPane.INFORMATION_MESSAGE);
}
}
if (ControlValidaciones.nControl12 == true)
{
if (Validaciones.nVal == true)
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Los datos del registro de inscripción fueron guardados con éxito !!","Atención",
JOptionPane.INFORMATION_MESSAGE);
}
}
///************************************************************************
///************************************************************************
///************************************************************************
//*** Desencripta los datos a través de las clases de control
if (MenuAdministrador.nControl3 == true)
{
SeUsuario = Desencriptar(ControlUsuarios.vUsuario);
SeNombre = Desencriptar(ControlUsuarios.vNombre);
SeContrasena = Desencriptar(ControlUsuarios.vContrasena);
ControlUsuarios.vUsuario = SeUsuario;
ControlUsuarios.vNombre = SeNombre;
ControlUsuarios.vContrasena = SeContrasena;
}
if (MenuAdministrador.nControl4 == true && MenuEstudiante.adsCedula.equals("") ||
MenuEstudiante.nControl4 == true)
{
SeNombre = Desencriptar(ControlEstudiantes.vNombre);
ControlEstudiantes.vNombre = SeNombre;
}
if (MenuAdministrador.nControl6 == true && MenuEstudiante.adsCedula.equals("") ||
MenuEstudiante.nControl6 == true)
{
SeNombre = Desencriptar(ControlHistorico.vNombre);
ControlHistorico.vNombre = SeNombre;
}
if (MenuAdministrador.nControl9 == true && MenuEstudiante.adsCedula.equals("") ||
MenuEstudiante.nControl9 == true)
{
SeNombre = Desencriptar(ControlInscripciones.vNombre);
ControlInscripciones.vNombre = SeNombre;
}
if (MenuAdministrador.nControl11 == true && MenuEstudiante.adsCedula.equals("") ||
MenuEstudiante.nControl11 == true)
{
SeNombre = Desencriptar(ControlValidaciones.nNombre);
ControlValidaciones.nNombre = SeNombre;
}
}
///************************************************************************
///*** ASPECTO: SEGURIDAD - ATRIBUTO: DISPONIBILIDAD
///*** POINCUT: OPERACIÓN POR PERSONAS
///************************************************************************
///************************************************************************
///*** POINTCUT Operacion atraviesa ortogonalmente a las clases:
///*** ControlUsuarios,ControlEstudiantes,ControlHistorico,ControlInscripciones,
///*** ControlValidaciones en los métodos GuardarDatos(),ActualizarDatos()
///************************************************************************
pointcut Operacion(): (execution(*
execution(*
execution(*
execution(*
execution(*
execution(*
execution(*
execution(*
ControlUsuarios.GuardarDatos(..)) ||
ControlEstudiantes.GuardarDatos(..))||
ControlHistorico.GuardarDatos(..))||
ControlInscripciones.GuardarDatos(..))||
ControlValidaciones.GuardarDatos(..))||
ControlUsuarios.ActualizarDatos(..))||
ControlEstudiantes.ActualizarDatos(..))||
ControlHistorico.ActualizarDatos(..)));
///************************************************************************
///*** Advise before: pointcut Operacion()
///************************************************************************
before (): Operacion()
{
//*** Ejecuta el método IngresaCaracteres que muestra una imagen con
//*** caracteres, con la finalidad de forzar al operador a escribir estos
//*** caracteres para comprobar que es una persona y no un programa
//*** automatizado el que ingresa los datos a través de las clases de control
if (ControlUsuarios.nControl2 == true)
{
if (ControlUsuarios.nRegistro == true || MenuAdministrador.nMEU == true)
{
IngresaCaracteres();
if (SeCaracter.equals(SeCodigo))
{
ControlUsuarios.nRegistro = false;
if (ExisteUsuario(ControlUsuarios.vUsuario,ControlUsuarios.vContrasena) == true
&& Usuarios.nIngresa == false)
ControlUsuarios.vDato = "Incorrecto";
}
else
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Acceso denegado, no se pueden guardar los datos !!","Atención",
JOptionPane.ERROR_MESSAGE);
if (MenuAdministrador.nMEU == true)
ControlUsuarios.nRegistro = true;
}
}
}
if (ControlEstudiantes.nControl5 == true)
{
if (ControlEstudiantes.nRegistro == true || MenuAdministrador.nMEU == true)
{
IngresaCaracteres();
if (SeCaracter.equals(SeCodigo))
{
ControlEstudiantes.nRegistro = false;
}
else
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Acceso denegado, no se pueden guardar los datos !!","Atención",
JOptionPane.ERROR_MESSAGE);
if (MenuAdministrador.nMEU == true)
ControlEstudiantes.nRegistro = true;
}
}
}
if (ControlHistorico.nControl7 == true)
{
if (ControlHistorico.nRegistro == true || MenuAdministrador.nMEU == true)
{
IngresaCaracteres();
if (SeCaracter.equals(SeCodigo))
{
ControlHistorico.nRegistro = false;
}
else
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Acceso denegado, no se pueden guardar los datos !!","Atención",
JOptionPane.ERROR_MESSAGE);
if (MenuAdministrador.nMEU == true)
ControlHistorico.nRegistro = true;
}
}
}
if (ControlInscripciones.nControl10 == true)
{
if (ControlInscripciones.nRegistro == true || MenuAdministrador.nMEU == true)
{
IngresaCaracteres();
if (SeCaracter.equals(SeCodigo))
{
ControlInscripciones.nRegistro = false;
}
else
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Acceso denegado, no se pueden guardar los datos !!","Atención",
JOptionPane.ERROR_MESSAGE);
if (MenuAdministrador.nMEU == true)
ControlInscripciones.nRegistro = true;
}
}
}
if (ControlValidaciones.nControl12 == true)
{
if (ControlValidaciones.nRegistro == true || MenuAdministrador.nMEU == true)
{
IngresaCaracteres();
if (SeCaracter.equals(SeCodigo))
{
ControlValidaciones.nRegistro = false;
}
else
{
Toolkit.getDefaultToolkit().beep();
JOptionPane.showMessageDialog(null,
"¡¡ Acceso denegado, no se pueden guardar los datos !!","Atención",
JOptionPane.ERROR_MESSAGE);
if (MenuAdministrador.nMEU == true)
ControlValidaciones.nRegistro = true;
}
}
}
}
///************************************************************************
///*** ASPECTO: SEGURIDAD - ATRIBUTO: CONFIDENCIALIDAD
///*** POINCUT: ENCRIPTAMIENTO DE DATOS
///************************************************************************
///************************************************************************
///*** POINTCUT Encriptar atraviesa ortogonalmente a las clases:
///*** ControlPassword,ControlUsuarios,ControlEstudiantes en el método
///*** IniciarVariables()
///************************************************************************
pointcut Encriptar(): (execution(* ControlPassword.IniciarVariables(..))||
execution(* ControlUsuarios.IniciarVariables(..))||
execution(* ControlEstudiantes.IniciarVariables(..)));
///************************************************************************
///*** Advise after: pointcut Encriptar()
///************************************************************************
after(): Encriptar()
{
//*** Encripta los datos a través de las clases de control
if (ControlPassword.nControl1 == true)
{
SeUsuario = Encriptar(ControlPassword.nUsuario);
SeContrasena = Encriptar(ControlPassword.nContrasena);
ControlPassword.nUsuario = SeUsuario;
ControlPassword.nContrasena = SeContrasena;
}
if (ControlUsuarios.nControl2 == true)
{
SeUsuario = Encriptar(ControlUsuarios.vUsuario);
SeNombre = Encriptar(ControlUsuarios.vNombre);
SeContrasena = Encriptar(ControlUsuarios.vContrasena);
SeConfContrasena = Encriptar(ControlUsuarios.vConfContrasena);
ControlUsuarios.vUsuario = SeUsuario;
ControlUsuarios.vNombre = SeNombre;
ControlUsuarios.vContrasena = SeContrasena;
ControlUsuarios.vConfContrasena = SeConfContrasena;
}
if (ControlEstudiantes.nControl5 == true)
{
SeNombre = Encriptar(ControlEstudiantes.vNombre);
ControlEstudiantes.vNombre = SeNombre;
}
}
///************************************************************************
///*** POINTCUT Desencriptar atraviesa ortogonalmente a las clases:
///*** ControlUsuarios,ControlEstudiantes en el método
///*** ObtenerDatos()
///************************************************************************
pointcut Desencriptar(): (execution(*
execution(*
execution(*
execution(*
ControlPassword.ObtenerDatos(..))||
TablaEstudiantes.ObtenerDatos(..))||
TablaValidaciones.ObtenerDatos(..))||
TablaUsuarios.ObtenerDatos(..)));
///************************************************************************
///*** Advise after: pointcut Desencriptar()
///************************************************************************
after(): Desencriptar()
{
//*** Desencripta los datos a través de las clases de control
if (ControlPassword.nControl1 == true)
{
SeUsuario = Desencriptar(ControlPassword.tuUsuario);
ControlPassword.tuUsuario = SeUsuario;
}
if (ControlEstudiantes.nControl5)
{
SeNombre = Desencriptar(TablaEstudiantes.teNombre);
TablaEstudiantes.teNombre = SeNombre;
}
if (ControlValidaciones.nControl12)
{
SeNombre = Desencriptar(TablaValidaciones.teNombre);
TablaValidaciones.teNombre = SeNombre;
}
if (ControlUsuarios.nControl2 == true)
{
SeUsuario = Desencriptar(TablaUsuarios.tuUsuario);
TablaUsuarios.tuUsuario = SeUsuario;
}
}
///************************************************************************
///*** ASPECTO: SEGURIDAD
///*** Métodos y funciones del aspecto AspectoSeguridad
///************************************************************************
//*** Se define el método ValidarCedula para validar si la cédula es un número
public boolean ValidarCedula(String Cedula)
{
try
{
Integer.parseInt(Cedula);
return true;
}
catch (Exception e)
{
return false;
}
}
//*** Se define el método ValidarCodigo para validar si el código es un número
public boolean ValidarCodigo(String Codigo)
{
try
{
Integer.parseInt(Codigo);
return true;
}
catch (Exception e)
{
return false;
}
}
//*** Se define el método ExisteUsuario para buscar si existe usuario y contraseña
public boolean ExisteUsuario(String MiUsuario,String MiContrasena)
{
try
{
nConectaB = nConexion.HacerConexion();
int sw = 0;
while(sw == 0)
{
String sql = "SELECT * FROM USUARIOS WHERE NombreUsuario= '" + MiUsuario
+ "' OR ClaveUsuario = '" + MiContrasena + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
}
if(sw == 0)
{
nConectaB.close();
return false;
}
rs.close();
}
nConectaB.close();
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método ExisteCedulaUsuario para buscar si existe un usuario
public boolean ExisteCedulaUsuario(String MiCedula)
{
try
{
nConectaB = nConexion.HacerConexion();
int sw = 0;
while(sw == 0)
{
String sql = "SELECT * FROM USUARIOS WHERE Val(CedulaUsuario)= '" + MiCedula + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
}
if(sw == 0)
{
nConectaB.close();
return false;
}
rs.close();
}
nConectaB.close();
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método ExisteCedulaEstudiante para buscar si existe un estudiante
public boolean ExisteCedulaEstudiante(String MiCedula)
{
try
{
nConectaB = nConexion.HacerConexion();
int sw = 0;
while(sw == 0)
{
String sql = "SELECT * FROM ESTUDIANTES WHERE Val(CedulaEstudiante)= '" + MiCedula +
"'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
}
if(sw == 0)
{
nConectaB.close();
return false;
}
rs.close();
}
nConectaB.close();
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método ExisteCodigoAsignatura para buscar si existe una asignatura
public boolean ExisteCodigoAsignatura(String MiCodigo)
{
try
{
nConectaB = nConexion.HacerConexion();
int sw = 0;
while(sw == 0)
{
String sql = "SELECT * FROM ASIGNATURAS WHERE Val(CodigoAsignatura)= '" + MiCodigo +
"'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
}
if(sw == 0)
{
nConectaB.close();
return false;
}
rs.close();
}
nConectaB.close();
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método BuscarUsuario para buscar usuario y contraseña
public boolean BuscarUsuario(String MiUsuario,String MiContrasena)
{
try
{
nConectaB = nConexion.HacerConexion();
int sw = 0;
while(sw == 0)
{
String sql = "SELECT * FROM USUARIOS WHERE NombreUsuario= '"+ MiUsuario
+ "' AND ClaveUsuario= '" + MiContrasena + "'";
PreparedStatement ps = nConectaB.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
while (rs.next())
{
sw = 1;
}
if(sw == 0)
{
nConectaB.close();
return false;
}
rs.close();
}
nConectaB.close();
return true;
}
catch(Exception e)
{
System.out.println("Se ha producido un error : " + e.toString());
return false;
}
}
//*** Se define el método Encriptar para cifrar una cadena de caracteres
public String Encriptar(String cad)
{
String clue ="";
for(int i = 0; i < cad.length(); i ++)
{
for(int j = 0; j < 256; j ++)
{
if(cad.charAt(i) == (char)j)
{
clue +=((char)(j + 5));
}
}
}
return clue;
}
//*** Se define el método Desencriptar para descifrar una cadena de caracteres
public String Desencriptar(String cad)
{
String clue ="";
for(int i = 0; i < cad.length(); i ++)
{
for(int j = 0; j < 256; j ++)
{
if(cad.charAt(i) == (char)j)
{
clue +=((char)(j - 5));
}
}
}
return clue;
}
//*** Se define el método IngresaCaracteres para forzar al operador a ingresar
//*** los caracteres que se muestran en la imagen
public void IngresaCaracteres()
{
JLabel Etiqueta = new JLabel(" ");
JLabel EtiquetaEscribir = new JLabel("Escriba los caracteres que ve en la imagen");
JLabel EtiquetaCaracter = new JLabel("Caracteres :");
TextField CajaTextoIngresa = new TextField(12);
JLabel EtiquetaImagen = new JLabel();
if (Img == 0)
{
SeCodigo = "G3NJBNKW";
ImageIcon imagen = new ImageIcon("C:/TG-319/4-IMAGENES/Cifrado0.JPG");
EtiquetaImagen.setIcon(imagen);
Img = Img + 1;
}
else if (Img == 1)
{
SeCodigo = "MUHDWW2E";
ImageIcon imagen = new ImageIcon("C:/TG-319/4-IMAGENES/Cifrado1.JPG");
EtiquetaImagen.setIcon(imagen);
Img = Img + 1;
}
else if (Img == 2)
{
SeCodigo = "JCCKKMSM";
ImageIcon imagen = new ImageIcon("C:/TG-319/4-IMAGENES/Cifrado2.JPG");
EtiquetaImagen.setIcon(imagen);
Img = Img + 1;
}
else if (Img == 3)
{
SeCodigo = "88HUDKWA";
ImageIcon imagen = new ImageIcon("C:/TG-319/4-IMAGENES/Cifrado3.JPG");
EtiquetaImagen.setIcon(imagen);
Img = Img + 1;
}
else if (Img == 4)
{
SeCodigo = "2XYCBBGM";
ImageIcon imagen = new ImageIcon("C:/TG-319/4-IMAGENES/Cifrado4.JPG");
EtiquetaImagen.setIcon(imagen);
Img = Img + 1;
}
else if (Img == 5)
{
SeCodigo = "BM8CRRUK";
ImageIcon imagen = new ImageIcon("C:/TG-319/4-IMAGENES/Cifrado5.JPG");
EtiquetaImagen.setIcon(imagen);
Img = Img + 1;
}
else if (Img == 6)
{
SeCodigo = "M6UXCB5C";
ImageIcon imagen = new ImageIcon("C:/TG-319/4-IMAGENES/Cifrado6.JPG");
EtiquetaImagen.setIcon(imagen);
Img = Img + 1;
}
else if (Img == 7)
{
SeCodigo = "3RY8YEX2";
ImageIcon imagen = new ImageIcon("C:/TG-319/4-IMAGENES/Cifrado7.JPG");
EtiquetaImagen.setIcon(imagen);
Img = Img + 1;
}
else if (Img == 8)
{
SeCodigo = "C5R4K99X";
ImageIcon imagen = new ImageIcon("C:/TG-319/4-IMAGENES/Cifrado8.JPG");
EtiquetaImagen.setIcon(imagen);
Img = Img + 1;
}
else
{
SeCodigo = "EDBXEXWA";
ImageIcon imagen = new ImageIcon("C:/TG-319/4-IMAGENES/Cifrado9.JPG");
EtiquetaImagen.setIcon(imagen);
Img = 0;
}
JPanel
JPanel
JPanel
JPanel
JPanel
PanelEscribir = new JPanel();
PanelImagen = new JPanel();
Panel1 = new JPanel(new BorderLayout(5,5));
Panel2 = new JPanel();
PanelPrincipal = new JPanel(new BorderLayout(5,5));
Panel1.add(EtiquetaEscribir, BorderLayout.NORTH);
Panel1.add(EtiquetaImagen, BorderLayout.SOUTH);
Panel2.add(EtiquetaCaracter);
Panel2.add(Etiqueta);
Panel2.add(CajaTextoIngresa);
PanelPrincipal.add(Panel1, BorderLayout.NORTH);
PanelPrincipal.add(Panel2, BorderLayout.SOUTH);
Object[] options = { "
Aceptar
", "
Cancelar
" };
JOptionPane.showOptionDialog(null, PanelPrincipal, "Guardar datos",
JOptionPane.DEFAULT_OPTION, JOptionPane.PLAIN_MESSAGE,
null, options, options[0]);
SeCaracter = CajaTextoIngresa.getText();
SeCaracter = SeCaracter.toUpperCase();
}
}
//***************************************************************************
// Fin Aspecto AspectoSeguridad
//***************************************************************************
ANEXO 6
MANUAL DEL USUARIO DEL SISTEMA
UNSIR Ver. 1.0.1
SISTEMA PARA EL REGISTRO DE INSCRIPCIÓN
Manual del Usuario
Elaborado por: Carlos Córdova
Tlf.: 0414-7695944
E-Mail: ccarloscc@gmail.com
Cumaná, enero 2.007
i
Contenido
Introducción ....................................................................................................... ii
Capítulo No. 1
Compatibilidad e instalación
Información general .............................................................................................
Instalación ............................................................................................................
Cómo ejecutar UNSIR Ver. 1.0.1 ........................................................................
Usuario y contraseña ............................................................................................
1
3
4
4
Capítulo No. 2
Opciones del menú archivo
Mantenimiento de la tabla asignaturas …............................................................. 6
Mantenimiento de la tabla pensum ……............................................................... 7
Capítulo No. 3
Funciones de la aplicación
Ingresar datos de los estudiantes ……..................................................................
Ingresar datos al histórico de notas …..................................................................
Registrar inscripción …........................................................................................
Ingresar datos de los usuarios del sistema ............................................................
8
10
12
15
Ayuda general ..................................................................................................... 17
ii
Introducción
UNSIR101 es un software desarrollado para registrar las inscripciones
regulares de una universidad. Es un caso de estudio para probar los beneficios que
pueda brindar la Programación Orientada a Aspectos (POA) a la Ingeniería de
Software. Está desarrollado en Java para trabajar bajo sistema operativo Windows
XP.
En este manual se presenta una descripción detallada del funcionamiento del
software UNSIR en su versión 1.0.1. El contenido de este manual está estructurado
en 3 capítulos, comenzando por la compatibilidad del programa, hardware necesario
para su funcionamiento e instalación del mismo, luego se describen los pasos a seguir
para cargar los datos a las tablas que conforman el sistema, registrar datos de los
estudiantes y registrar el proceso de inscripción. Todo esto se desarrolla de forma
amigable viajando por el menú de opciones y las pantallas de entrada y edición de
datos.
1
Capítulo No. 1
Compatibilidad e Instalación
INFORMACIÓN GENERAL
Esta aplicación tiene como objetivo general registrar y procesar los datos de las
inscripciones de los estudiantes de una universidad. Las funciones del código base
están diseñadas para procesar de forma sencilla los requerimientos del sistema. Está
desarrollado en Java para trabajar bajo sistema operativo Windows XP.
Este software está conformado por un menú principal, donde se generan las
funciones de entrada de datos, procesamiento y salida de la información por pantalla
e impresora.
Todas las opciones de la aplicación se pueden ejecutar mediante el menú de opciones.
Tecnología
La plataforma tecnológica mínima para el funcionamiento y operación de este
programa está sujeta a los siguientes requerimientos de hardware y software:
• Microcomputador con procesador Pentium o superior.
• 256 MB de memoria RAM.
• Disco duro de mediana capacidad.
• Unidad de CD-ROM.
• Microsoft Windows XP.
• Java JDK Edition 1.5.0.
2
• AspectJ 1.5.2.
• Microsoft Access 2003.
Software adicional:
DJ Java Decompiler 3.6.
NOTA:
Se recomienda para un mayor rendimiento un microcomputador con procesador
Pentium IV 1.0 Ghz o superior, 512 MB de RAM y un disco duro de gran capacidad.
Este software está diseñado para funcionar preferiblemente bajo Windows XP.
Organización de los datos y seguridad
La Base de Datos (Estudiantes.mdb) está integrada por 7 tablas, las cuales están
ubicadas en la carpeta o directorio donde se instala la aplicación en el equipo. El
nombre y la descripción de estas tablas se muestran a continuación:
USUARIOS
Tabla que contiene los nombres de usuarios y contraseñas.
ESTUDIANTES
Tabla (maestro) que contiene los datos de los estudiantes: cédula, nombre y apellido,
dirección, carrera, sexo, fecha de nacimiento, etc.
HISTORICO
Tabla que contiene los datos del histórico de calificaciones del estudiante.
INSCRIPCIONES
3
Tabla que almacena los datos de las asignaturas seleccionadas por el estudiante para
la inscripción.
VALIDACIONES
Tabla que almacena los datos del registro de la inscripción del estudiante, como
número del depósito bancario por concepto de aranceles, nombre del banco, fecha de
depósito, monto, etc.
ASIGNATURAS
Tabla para almacenar los datos de todas las asignaturas: código, nombre de la
asignatura y número de créditos.
PENSUM
Tabla que almacena los datos de la matriz curricular de todas las carreras que ofrece
la universidad: código carrera, código asignatura, semestre, pre-requisitos, etc.
INSTALACIÓN
Para instalar el sistema, se debe disponer de una computadora con sistema
operativo Microsoft Windows XP. Introducir el CD en la unidad correspondiente, al
cabo de 15 segundos se ejecutará el paquete instalador que se encuentra en el
directorio raíz del CD. Si no se ejecuta la instalación automática, se debe accesar a la
unidad de CD a través del explorador de Windows o “MI PC” y ejecutar el programa
instalador haciendo clic en el archivo InstalarUNSIRV101.exe. Seguir las
instrucciones que se indican en el instalador hasta que aparezca el botón “Terminar”,
si es necesario se debe reiniciar el sistema.
4
NOTA IMPORTANTE: Este instalador está diseñado y compilado de manera que
copie todas las clases necesarias para la ejecución del sistema, es importante señalar
que se debe tener instalado en el PC el Kit de Desarrollo de Java para el correcto
funcionamiento del mismo. Para trabajar con la implementación de aspectos y
AspectJ consulte el archivo de instalación y ejecución (INSTALACION.HLP)
CÓMO EJECUTAR UNSIR VER. 1.0.1
Una vez instalado los archivos (clases) en la computadora, se pueden compilar
y ejecutar a través del acceso directo que se crea en el escritorio. Para compilar y
ejecutar el código base a través del acceso directo, se debe hacer clic en el icono
“UNSIR V.1.0.1. (S-ASPECTOS)” que se instala en el escritorio, o a través del grupo
de programas UNSIR V.1.0.1.
USUARIO Y CONTRASEÑA
El usuario y contraseña por defecto es “123” y “123”, ver Figura 1.1, sin
embargo ésta se puede cambiar en la parte de Usuarios del menú principal.
Figura 1.1 Acceso al sistema
5
Cuando se inicia la aplicación, es necesario ingresar un nombre de usuario y
contraseña para hacer uso del programa y tener acceso a los datos. El nombre de
usuario y contraseña para utilizar la aplicación por primera vez es “123” y “123”
respectivamente con nivel de administrador. Para crear un usuario y contraseña y
hacer uso del programa. Siga los siguientes pasos:
• Escriba su nombre de usuario.
• Escriba su nombre completo.
• Seleccione el nivel de acceso (administrador o estudiante).
• Escriba una contraseña.
• Vuelva a escribir la contraseña para confirmarla.
• Si su contraseña contiene letras mayúsculas debe escribirla de la misma manera
cada vez que inicie la sesión para hacer uso de todas las opciones del programa.
• Anote y memorice su nombre de usuario y contraseña para ingresar al programa.
Contraseña nueva
• En la opción Usuarios del menú principal seleccione Registrar usuario y
contraseña.
• Ingrese los datos requeridos en la pantalla de entrada Registrar usuario y
contraseña y siga las instrucciones antes indicadas.
• Pulse el botón ACEPTAR para salvar los datos.
Dependiendo del nivel de acceso (administrador o estudiante), se mostrarán dos
tipos de menú de opciones. En el menú administrador se tendrá acceso a todas las
opciones del sistema. En el menú estudiante se tendrá acceso sólo a la consulta de
datos y al proceso de inscripción.
6
Capítulo No. 2
Opciones del menú archivo
El menú archivo contiene las opciones: Mantenimiento de la tabla asignaturas y
Mantenimiento de la tabla pensum.
MANTENIMIENTO DE LA TABLA ASIGNATURAS
Con esta opción se puede agregar, modificar o eliminar asignaturas. Para
ejecutar esta función vaya
al menú principal y haga clic en Archivo, luego
desplácese con el puntero del mouse y haga clic en Asignaturas. Una vez en la
pantalla que muestra el listado de las asignaturas pulse el botón REGISTRAR para
agregar una asignatura, CAMBIAR para modificar los datos de una asignatura
existente o ELIMINAR para eliminar una asignatura existente. Si no va a realizar
cambios pulse el botón CANCELAR.
7
MANTENIMIENTO DE LA TABLA PENSUM
Con esta opción se puede agregar, modificar o eliminar asignaturas a los
pensum de estudio de las carreras. Para ejecutar esta función vaya al menú principal
y haga clic en Archivo, luego desplácese con el puntero del mouse y haga clic en
Pensum. Una vez en la pantalla que muestra el listado de la matriz curricular pulse el
botón REGISTRAR para agregar una asignatura a la matriz, CAMBIAR para
modificar los datos de una asignatura existente o ELIMINAR para eliminar una
asignatura existente. Si no va a realizar cambios pulse el botón CANCELAR.
Capítulo No. 3
8
Funciones de la aplicación
INGRESAR DATOS DE LOS ESTUDIANTES
Con esta opción se puede registrar, cambiar y eliminar los datos personales de
un estudiante: número de cédula, nombre y apellido, dirección, fecha de nacimiento,
carrera, teléfono, correo, centro local, etc. Ejecute la siguiente rutina:
A) REGISTRAR ESTUDIANTE:
1) En el menú principal haga clic en Estudiantes, luego desplácese con el puntero
del mouse y haga clic en Registrar estudiante.
2) Una vez en la pantalla Registrar estudiante ingrese los datos requeridos en la
pantalla de entrada.
3) Pulse el botón ACEPTAR para salvar los cambios y regresar al menú principal.
B) CAMBIAR DATOS ESTUDIANTE:
1) En el menú principal haga clic en Estudiantes, luego desplácese con el puntero
del mouse y haga clic en Cambiar datos estudiante.
2) Ingrese el número de cédula del estudiante y pulse el botón ACEPTAR.
3) Una vez en la pantalla Cambiar datos estudiante edite o cambie los datos que se
muestran en la pantalla.
4) Pulse el botón ACEPTAR para salvar los cambios y regresar al menú principal.
C) ELIMINAR DATOS ESTUDIANTE:
9
1) En el menú principal haga clic en Estudiantes,
Estudiantes luego desplácese con el puntero
del mouse y haga clic en Eliminar estudiante.
2) Ingrese el número de cédula del estudiante y pulse el botón ACEPTAR.
3) Una vez en la pantalla Eliminar estudiante pulse el botón ELIMINAR, confirme
la acción a ejecutar para eliminar los datos o cancelar y regresar al menú principal.
D) CONSULTAR ESTUDIANTES:
1) En el menú principal haga clic en Estudiantes, luego desplácese con el puntero
del mouse y haga clic en Consultar datos estudiantes.
2) A continuación se muestra un listado con todos los estudiantes registrados en el
sistema. Pulse el botón ACEPTAR para regresar al menú principal.
10
INGRESAR DATOS AL HISTÓRICO DE NOTAS
Con esta opción se puede registrar, cambiar, eliminar y consultar los datos del
histórico de calificaciones del estudiante. Ejecute la siguiente rutina:
A) REGISTRAR HISTÓRICO DE CALIFICACIONES:
1) En el menú principal haga clic en Histórico, luego desplácese con el puntero del
mouse y haga clic en Histórico calificaciones estudiante.
2) Ingrese el número de cédula del estudiante y pulse el botón ACEPTAR.
3) Una vez en la pantalla Histórico de calificaciones del estudiante pulse el botón
REGISTRAR para seleccionar la asignatura, la calificación obtenida y el lapso
académico.
4) Pulse el botón ACEPTAR para salvar los cambios y regresar a la pantalla
anterior.
5) Pulse el botón CANCELAR para salir al menú principal.
B) CAMBIAR HISTÓRICO DE CALIFICACIONES:
1) En el menú principal haga clic en Histórico, luego desplácese con el puntero del
mouse y haga clic en Histórico calificaciones estudiante.
2) Ingrese el número de cédula del estudiante y pulse el botón ACEPTAR.
3) Una vez en la pantalla Histórico de calificaciones del estudiante seleccione un
registro del listado que aparece en pantalla y pulse el botón CAMBIAR para
cambiar la asignatura, la calificación obtenida y el lapso académico.
4) Pulse el botón ACEPTAR para salvar los cambios y regresar a la pantalla
anterior.
5) Pulse el botón CANCELAR para salir al menú principal.
11
C) ELIMINAR HISTÓRICO DE CALIFICACIONES:
1) En el menú principal haga clic en Histórico, luego desplácese con el puntero del
mouse y haga clic en Histórico calificaciones estudiante.
2) Ingrese el número de cédula del estudiante y pulse el botón ACEPTAR.
3) Una vez en la pantalla Histórico de calificaciones del estudiante seleccione un
registro del listado que aparece en pantalla y pulse el botón ELIMINAR, confirme
la acción para eliminar el registro del histórico del estudiante.
4) Pulse el botón CANCELAR para salir al menú principal.
D) CONSULTAR HISTÓRICO DE CALIFICACIONES:
1) En el menú principal haga clic en Histórico, luego desplácese con el puntero del
mouse y haga clic en Consultar histórico estudiante.
2) Ingrese el número de cédula del estudiante y pulse el botón ACEPTAR.
3) A continuación se muestra el histórico de calificaciones del estudiante y el índice
académico. Pulse el botón ACEPTAR para regresar al menú principal.
12
REGISTRAR INSCRIPCIÓN
Con esta opción se puede seleccionar las asignaturas a inscribir por parte del
estudiante, registrar la inscripción del estudiante, validar la inscripción del estudiante
y consultar las inscripciones que han sido validadas. Cuando el nivel de acceso es de
estudiante, sólo se tienen las opciones de seleccionar las asignaturas y registrar la
inscripción. Ejecute la siguiente rutina:
A) SELECCIONAR ASIGNATURAS:
1) En el menú principal haga clic en Inscripciones, luego desplácese con el puntero
del mouse y haga clic en Seleccionar asignaturas de estudiante.
2) Ingrese el número de cédula del estudiante y pulse el botón ACEPTAR.
3) Una vez en la pantalla Inscripción regular seleccione una asignatura del listado de
ofertas y pulse el botón AÑADIR para agregar la asignatura al listado de
asignaturas a inscribir. Pulse el botón QUITAR para eliminar una asignatura del
listado de asignaturas a inscribir.
4) Pulse el botón GUARDAR para guardar la selección de asignaturas y salir al
menú principal.
13
B) REGISTRAR Y VALIDAR INSCRIPCIÓN:
1) En el menú principal haga clic en Inscripciones, luego desplácese con el puntero
del mouse y haga clic en Registrar y validar inscripción de estudiante.
2) Ingrese el número de cédula del estudiante y pulse el botón ACEPTAR.
3) Una vez en la pantalla Validar inscripción registre el nombre de la entidad
bancaria, número de depósito, fecha de depósito y monto del depósito por
concepto de aranceles, active la casilla de validación y pulse el botón GUARDAR
para guardar el registro de inscripción y salir al menú principal.
4) A continuación se le pregunta al usuario si quiere imprimir la planilla de
inscripción.
NOTA:
14
Cuando el nivel de acceso es de estudiante, sólo se registra la inscripción.
Cuando el nivel de acceso es de estudiante y se registra la inscripción, no se pueden
modificar los datos del registro ni volver a seleccionar asignaturas. Esta opción sólo
es prioridad del nivel administrador.
C) CONSULTAR ESTUDIANTES INSCRITOS:
1) En el menú principal haga clic en Inscripciones, luego desplácese con el puntero
del mouse y haga clic en Consultar estudiantes inscritos.
2) A continuación se muestra el listado con todos los estudiantes que han sido
registrados en el sistema y cuya inscripción fue validada. Pulse el botón
ACEPTAR para regresar al menú principal.
INGRESAR DATOS DE LOS USUARIOS DEL SISTEMA
15
Con esta opción se puede registrar, cambiar o eliminar usuarios y contraseñas
de acceso al sistema. Ejecute la siguiente rutina:
A) REGISTRAR USUARIO:
1) En el menú principal haga clic en Usuarios, luego desplácese con el puntero del
mouse y haga clic en Registrar usuario y contraseña.
2) Una vez en la pantalla Registrar usuario ingrese los datos requeridos en la
pantalla de entrada.
3) Pulse el botón ACEPTAR para salvar los cambios y regresar al menú principal.
B) CAMBIAR DATOS USUARIO:
1) En el menú principal haga clic en Usuarios, luego desplácese con el puntero del
mouse y haga clic en Cambiar usuario y contraseña.
2) Ingrese el número de cédula del usuario y pulse el botón ACEPTAR.
3) Una vez en la pantalla Cambiar usuario y contraseña edite o cambie los datos que
se muestran en la pantalla.
4) Pulse el botón ACEPTAR para salvar los cambios y regresar al menú principal.
C) ELIMINAR DATOS USUARIO:
1) En el menú principal haga clic en Usuarios, luego desplácese con el puntero del
mouse y haga clic en Eliminar usuario y contraseña.
2) Ingrese el número de cédula del usuario y pulse el botón ACEPTAR.
3) Una vez en la pantalla Eliminar usuario y contraseña pulse el botón
ELIMINAR, confirme la acción a ejecutar para eliminar los datos o cancelar y
regresar al menú principal.
16
D) CONSULTAR USUARIOS:
1) En el menú principal haga clic en Usuarios, luego desplácese con el puntero del
mouse y haga clic en Consultar usuarios.
2) A continuación se muestra un listado con todos los usuarios registrados en el
sistema. Pulse el botón ACEPTAR para regresar al menú principal.
NOTA:
* No se permiten crear nuevos usuarios con un nombre de Usuario ya existente.
* No se permiten crear contraseñas que ya existan.
* El número máximo de caracteres para el Usuario es de 14.
* El número máximo de caracteres para la Contraseña es de 8.
17
AYUDA GENERAL
Para ejecutar este sistema de inscripción, debe instalar correctamente en su
computador el JDK de Java (Java JDK Edition 1.5.0.) para compilar y ejecutar las
clases que forman el código base.
Para ejecutar el sistema y probar la tecnología de aspectos, debe instalar
correctamente en su computador AspectJ (AspectJ Development Environment
(AJDE) versión 1.5.2) para hacer el tejido (weaving), compilar y ejecutar las clases
que forman el código base y el aspecto.
Para utilizar la base de datos (Estudiantes.mdb) y hacer transacciones con los
registros como agregar, modificar o eliminar datos a través del sistema, debe crear el
origen de datos.
Para una descripción más detallada, consulte el archivo de ayuda de instalación
y ejecución (INSTALACION.HLP) que se encuentra en el CD anexo.
Descargar

Texto - Universidad Nacional Abierta