ingeniería de software ii información obtenida de internet universidad de san martin de porres...

Ingeniería de Software IIInformación obtenida de Internet

UNIVERSIDAD DE SAN MARTIN DE PORRESFACULTAD DE INGENIERIA Y ARQUITECTURA

Profesor: Ing. Luis Palacios Quichíz

Caso Práctico UML

Curso de UML para el Servicio de Informática

Universidad de Murcia

Julio de 2.000

Curso UML 3

Contenido

• Requisitos de la aplicación

• Casos de uso

• Modelo conceptual

• Modelo de Análisis y Diseño

• Aspectos Avanzados del Diseño

Curso UML 4

Requisitos de la aplicación

• Servicio de Tutorías Virtuales para la Universidad.

• Requisitos:– El alumno accederá a la aplicación a través del web.

– Los usuarios se identificarán en el sistema utilizando tarjetas inteligentes.

– Permitirá a los alumnos realizar consultas electrónicas.

– Sistema de consultas on-line.

– El alumno tendrá un buzón de nuevas respuestas.

– El profesor tendrá un buzón de nuevas consultas.

Curso UML 5

Requisitos de la aplicación

• Requisitos (continuación):– El alumno organizará las consultas por asignatura,

profesor y tema. – El profesor organizará las consultas por asignatura,

alumno y tema.– El profesor podrá determinar cuando desea establecer las

tutorías on-line para una asignatura.– La Universidad desea conocer para cada profesor:

• Cumplimiento horario tutorías.• Número de horas de tutorías on-line.• Número de horas de consultas on-line.• Número de consultas respondidas.

Curso UML 6

Reglas de Negocio

• Restricciones que afectan a las informaciones y acciones de la organización:– Horas de tutorías del profesor >= 6

– Un usuario no puede fallar durante el proceso de identificación más de 3 veces

Curso UML 7

Diagrama de Casos de Uso

Explorar Consultas Alumno Crear Tema Consulta

Realizar Consulta

Consultar Buzon Entrada Alumno

Explorar Consultas Profesor

Responser Consulta

Consulta en linea

Consultar Buzon Entrada Profesor

Establecer Tutorias

Alumno

(from Alumno)

Profesor

(from Profesor)

Identificacion Alumno Identificación Profesor

Identificación

<<extend>> <<extend>>

Universitario

Curso UML 8

Plantilla Casos de Uso

• Caso de uso: nombre del caso de uso• Objetivo: propósito del caso de uso• Actores: actores que intervienen• Precondiciones: condiciones que deben cumplirse

para poder comenzar el caso de uso• Pasos: secuencia normal de acciones• Variaciones: variaciones de la secuencia normal• Extensiones: extensiones del caso de uso

Curso UML 9

CDU: Realizar Consulta

• Objetivo: el alumno realiza una consulta electrónica al profesor de una asignatura

• Actores: Alumno • Pasos:

– 1. A: Selecciona el tema

– 2. A: Escribe la consulta y su título

– 3. S: Registrar consulta asociada al tema

Curso UML 10

CDU: Crear Tema Consulta

• Objetivo: establecer un nuevo tema de consulta para las tutorías con un profesor

• Actores: Alumno• Pasos:

– 1. A: Selecciona la asignatura y el profesor

– 2. A: Establece nuevo tema de consulta

– 3. S: Registrar el tema de consulta asociado al profesor y la asignatura

Curso UML 11

CDU: Crear Tema Consulta

• Variaciones:– 1.a. El tema de consulta existe

• 1.a.1: Indicar error

• 1.a.2: Finalizar cdu.

Curso UML 12

CDU: Consultar Buzón Entrada Alumno

• Objetivo: el alumno consulta las nuevas consultas contestadas por los profesores

• Actores: Alumno• Pasos:

– 1. S: Muestra todas las consultas recién contestadas por los profesores.

– 2. A: Lee las consultas del buzón.

Curso UML 13

CDU: Explorar Consultas Alumno

• Objetivo: el alumno explora las consultas, junto con sus respuestas, realizadas a los profesores

• Actores: Alumno• Pasos: *

– 1. S: Muestra las asignaturas para las que está matriculado el alumno

– 2. A: Selecciona Asignatura

– 3. S: Muestra los profesores de la asignatura seleccionada

– 4. A: Selecciona Profesor

Curso UML 14

CDU: Explorar Consultas Alumno

• Pasos (continuación):– 5. S: Muestra los temas para la Asignatura-Profesor-

Alumno

– 6. A: Selecciona Tema

– 7. S: Muestras las consultas para ese Tema

Curso UML 15

CDU: Consulta en Línea

• Objetivo: el alumno realiza una consulta en línea con el profesor.

• Actores: Alumno (iniciador), Profesor• Precondiciones: profesor está en línea y no

ocupado• Pasos:

– 1. A Alumno: Solicita la consulta al profesor.

– 2. S: Avisa al Profesor

– 3. A Profesor: Acepta la consulta.

– 4. S: Avisa al Alumno

Curso UML 16

CDU: Consulta en Línea

• Pasos (continuación):– 5. A Alumno-Profesor: Intercambian mensajes.

– 6. S: Envía mensajes al otro interlocutor

– 7. A Alumno-Profesor: Finaliza la consulta.

– 8. S: Notifica la finalización al otro interlocutor

– 9. S: Registrar periodo de tutoria asociado al Profesor y al Alumno

• Variaciones:– 2. a. El profesor no acepta la consulta

• 2.a.1: Finaliza cdu.

Curso UML 17

CDU: Responder Consulta

• Objetivo: el profesor responde una consulta electrónica de un alumno

• Actores: Profesor • Pasos:

– 1. A: Selecciona la consulta a responder

– 2. S: Muestra el contenido de la consulta para su edición

– 3. A: Escribe la respuesta dentro de la consulta

– 4. S: Registra la respuesta y la asocia a la consulta

Curso UML 18

CDU: Consultar Buzón Entrada Profesor

• Objetivo: el profesor examina las consultas no contestadas

• Actores: Profesor• Pasos:

– 1. S: Muestra todas las consultas no contestadas del profesor

– 2. A: Leer consultas del buzón.

Curso UML 19

CDU: Explorar Consultas Profesor

• Objetivo: el profesor explora las consultas, contestadas o no, de los alumnos

• Actores: Profesor• Pasos: *

– 1. A: Selecciona la Asignatura

– 2. S: Muestra los alumnos matriculados para la Asignatura

– 3. A: Selecciona el Alumno

– 4. S: Muestra los temas del Alumno para la Asignatura y el Profesor

Curso UML 20

CDU: Explorar Consultas Profesor

• Pasos: (continuación)– 5. A: Selecciona el Tema

– 6. S: Muestra las consultas de ese tema

Curso UML 21

CDU: Establecer Tutorías

• Objetivo: permite a un profesor establecer las asignaturas para las que estará en tutoría

• Actores: Profesor• Pasos:

– 1. A: Seleccionar asignatura y establecer estado (en línea o fuera de línea)

– 2. S: Registrar el cambio de tutorías y actualizar las estadísticas (cumplimiento horario tutorías y horas de tutorías)

Curso UML 22

CDU: Identificación

• Objetivo: obtener y validar la identidad de un usuario de la Universidad

• Actores: Universitario• Pasos:

– 1. S: Solicita tarjeta inteligente

– 2. A: Introduce tarjeta inteligente

– 3. S: Solicita el PIN

– 4. A: Introduce el PIN

– 5. S: Comprobar identidad

– 6. S: Devolver identidad

Curso UML 23

CDU: Identificación

• Variaciones:– 5. a. El PIN no es correcto

• 5.a.1: Solicitar el PIN hasta 3 veces

• Extensiones:– Tipo de usuario

Curso UML 24

CDU: Identificación Alumno

• Identificación Alumno extends Identificación• Objetivo: comprobar la identidad del alumno• Actores: Alumno• Precondiciones: • Pasos:

– 1: Pasos cdu Identificación

– 2: S: Obtener identidad alumno

Curso UML 25

CDU: Identificación Profesor

• Identificación Profesor extends Identificación• Objetivo: comprobar la identidad del profesor• Actores: Profesor• Precondiciones: • Pasos:

– 1: Pasos cdu Identificación

– 2: S: Obtener identidad profesor

Curso UML 26

Interfaces Gráficas (Pantallas)

• Una manera adecuada de validar los requisitos del usuario es construir las interfaces gráficas

• Nos ayudan a ver las conexiones entre casos de uso

• Permiten definir los llamados casos de uso reales: – Hacen referencia a los elementos de interacción actor-

sistema

– Ejemplo de elementos: cuadros de edición, botones, listbox, ...

Curso UML 27

Pantallas: Realizar Consulta

Curso UML 28

Pantallas: Crear Tema Consulta

Curso UML 29

Pantallas: Buzón de Entrada Alumno

Curso UML 30

Pantallas: Explorador Alumno

Curso UML 31

Pantallas: Consulta en Línea

Curso UML 32


Curso UML 33


Curso UML 34

Pantallas: Responder Consulta

Curso UML 35

Pantallas: Buzón de Entrada Profesor

Curso UML 36

Pantallas: Explorador Profesor

Curso UML 37

Pantallas: Establecer Tutorías

Curso UML 38

Pantallas: Identificación

Curso UML 39

Modelo Conceptual

• Conceptos y Atributos:– Alumno:

• DNI

• Nombre

– Profesor:• DNI

• Nombre

– Asignatura:• Código

• Nombre

Curso UML 40

Modelo Conceptual

• Conceptos y Atributos:– Consulta:

• Título

• Fecha

• Hora

• Mensaje

– Respuesta:• Fecha

• Hora

• Mensaje

– Tema:• Nombre

Curso UML 41

Modelo Conceptual

• Conceptos y atributos:– Horario Tutorías

– Franja Horaria:• hora de inicio

• hora de fin

• día de la semana

Curso UML 42

Modelo Conceptual

• Asociaciones entre conceptos:– Consulta tiene asociada Respuesta

– Alumno realiza Consulta

– Profesor responde Consulta

– Consulta realizada a Profesor

– Profesor tiene Horario Tutorías

– Horario Tutorías definido mediante Franja Horaria

– Consulta relacionada con Asignatura

– Alumno matriculado en Asignatura

– Profesor imparte Asignatura

Curso UML 43

Modelo Conceptual

• Asociaciones entre conceptos:– Alumno tutoría en línea Profesor

– Profesor establece tutoría Asignatura

– Tema tiene Consulta

– Tema organiza consultas Asignatura

– Tema organiza consultas Profesor

Curso UML 44

numeroHoras >= 6

FranjaHoraria

inicio : Timefin : Timedia : Day

(from Profesor)

HorarioTutorias

/ numeroHoras : Integer

(from Profesor)

11

definido mediante

Profesor

DNI : StringNombre : String

(from Profesor) 11

tiene

Respuesta

mensaje : String

fecha : Datehora : Time

(from Comun)

Profesor

(from Profesor)

Asignatura

codigo : Stringnombre : String

(from Universidad)

imparte

establece tutoría

Consulta

titulo : Stringfecha : Datehora : Timemensaje : String

estado : String

(from Comun)

responde

realizada a

relacionada con

0..11 0..11

tiene asociada

Asignatura(from Universidad)

Profesor

(from Profesor)

Alumno


(from Alumno)

tutoria en linea

1..*

1..*

1..*

1..*

matriculado enrealiza

Tema

nombre : String

(from Comun)

1

0..*

1

0..*

contiene

organiza consultas

organiza consultas

tema de consulta

Curso UML 45

Modelado de Análisis y Diseño

• Diagramas de Secuencia de Sistema

• Contratos de operaciones

• Diagramas de interacción

• Diagramas de clases

Curso UML 46

Diagramas de Secuencia del Sistema

• Describen los eventos que envía el actor al sistema• Conviene realizar un Diagrama de Secuencia de

Sistema (DSS) para cada caso de uso.• Ejemplo:

: Alumno : Sistema

seleccionarConsulta( )

marcarConsultaLeida( )

Curso UML 47

Contratos

• Los contratos nos permiten establecer las responsabilidades de cada operación.

• Definen explícitamente los cambios en el sistema después de finalizar la operación.

• Realizaremos contratos para todas las operaciones del sistema

• Para las operaciones del sistema debemos encontrar una clase Controlador (alternativas):– Clase que representa al Sistema.

– Clase que representa un manejador del caso de uso.

Curso UML 48

Plantilla Contratos

• Nombre: signatura de la operación• Responsabilidades: responsabilidades de la

operación • Tipo: clase que contiene la operación• Notas: notas• Excepciones: excepciones• Salida: salida que no sea por pantalla

Curso UML 49

Plantilla Contratos

• Precondiciones: condiciones que han de cumplirse antes de ejecutar la operación

• Postcondiciones: estado del sistema después de la ejecución del método.

Curso UML 50

Diagramas de Interacción

• Para cada operación del sistema construimos un Diagrama de Interacción (DI): – Diagrama de Colaboración

– Diagrama de Secuencia

• En los diagramas obviamos al acceso a los objetos controlador: – Se realiza a través de un objeto Singleton.

Equivalentes

objeto : GestorAlumno

G

1: getInstancia( )

instancia : GestorAlumno

2: getExplorador( )

Curso UML 51

DSS: Realizar Consulta

: Alumno

: Sistema

nuevaConsulta( )

Curso UML 52

Contratos: Realizar Consulta

• Nombre: nuevaConsulta (titulo: String; mensaje: String, tema: Tema)

• Responsabilidades: crea una nueva consulta y la asocia a un tema (asignatura-profesor)

• Tipo: GestorConsultas• Postcondiciones:

– Un objeto Consulta es creado

– Consulta.titulo = titulo y Consulta.mensaje = mensaje

– Una asociación tema-consulta es creada.

Curso UML 53

DI: nuevaConsulta

: Alumno :

GestorConsultasnuevaConsulta

: Consultatema : Tema

nuevaConsulta(String, String, Tema)

create( )

setTitulo(String)

setMensaje(String)

addConsulta(Consulta)

Curso UML 54

DSS: Crear Tema Consulta

: Alumno : Sistema

nuevoTema()

Curso UML 55

Contratos : Crear Tema Consulta

• Nombre: nuevoTema (tema: String, asignatura: Asignatura, profesor: Profesor)

• Responsabilidades: crear un nuevo tema de consulta asociandolo al alumno, al profesor y a la asignatura

• Notas: acceso al objeto Alumno a través de la clase Singleton

• Tipo: GestorConsultas• Excepciones: nombre del tema existe

Curso UML 56

Contratos : Crear Tema Consulta

• Postcondiciones:– Objeto Tema es creado

– Asociación Tema-Asignatura es creada

– Asociación Tema-Profesor es creada

– Asociación Alumno-Tema es creada

Curso UML 57

DI: nuevoTema

: Alumno : GestorConsultas nuevoTema :

Temaalumno : Alumno

nuevoTema(String, Profesor, Asignatura)create( )

setProfesor(Profesor)

setAsignatura(Asignatura)

addTema(Tema, Profesor, Asignatura)

Curso UML 58

DSS: Consultar Buzón Entrada Alumno

: Alumno : Sistema



Curso UML 59

Contratos: Consultar Buzón Entrada Alumno

• Nombre: String seleccionarConsulta (consulta: Consulta)

• Responsabilidades: recordar la consulta seleccionada y devolver su contenido

• Tipo: BuzonAlumno• Postcondiciones:

– Asociación BuzonAlumno-Consulta es creada

Curso UML 60

DI: seleccionarConsulta

: Alumno :

BuzonAlumno : Consulta

seleccionarConsulta(Consulta)

setConsulta(Consulta)

getMensaje( )

Curso UML 61

Contratos: Consultar Buzón Entrada Alumno

• Nombre: marcarConsultaLeida()• Responsabilidades: cambiar el estado de la

consulta seleccionada• Tipo: BuzonAlumno• Precondiciones: consulta seleccionada

(seleccionarConsulta)• Postcondiciones:

– consulta.estado = “leída”

Curso UML 62

DI: marcarConsultaLeida

: Alumno :

BuzonAlumnoconsulta : Consulta


setLeida( )

Curso UML 63

DSS: Explorar Consultas Alumno

: Alumno : Sistema

seleccionarAsignatura( )

seleccionarProfesor( )

seleccionarTema( )


nuevaConsulta( )

nuevoTema(String, Profesor, Asignatura)

cdu "Realizar Consulta"

cdu "Crear Tema Consulta"

Curso UML 64

Contratos: Explorar Consultas Alumno

• Nombre: List (Profesor) seleccionarAsignatura (asignatura: Asignatura)

• Responsabilidades: recordar la asignatura y devolver los profesores de la asignatura

• Tipo: ExploradorAlumno• Postcondiciones:

– Asociación ExploradorAlumno-asignatura es creada

Curso UML 65

DI: seleccionarAsignatura

: Alumno : ExploradorAlumno : Asignatura

seleccionarAsignatura(Asignatura)

getProfesores( )

setAsignatura( Asignatura)

Curso UML 66


• Nombre: List (Tema) seleccionarProfesor (profesor: Profesor)

• Responsabilidades: recordar el profesor seleccionado y mostrar los temas para la asignatura-profesor-alumno

• Tipo: ExploradorAlumno• Notas: acceso al Alumno a través del Singleton• Postcondiciones:

– Asociación ExploradorAlumno-profesor es creada

Curso UML 67

DI: seleccionarProfesor

: Alumno : ExploradorAlumno alumno : Alumno

seleccionarProfesor(Profesor)


getTemas(Asignatura, Profesor)

Curso UML 68


• Nombre: List(Consulta) seleccionarTema (tema: Tema)

• Responsabilidades: recordar el tema seleccionado y devolver todas las consultas para ese tema


– Asociación ExploradorAlumno-tema es creada

Curso UML 69

DI: seleccionarTema

: Alumno :

ExploradorAlumno : Tema

seleccionarTema(Tema)

getConsultas( )

setTema(Tema)

Curso UML 70



• Responsabilidades: recordar la consulta y devolver el contenido del mensaje


– Asociación ExploradorAlumno-consulta es creada

Curso UML 71


: Alumno :

ExploradorAlumno : Consulta



getMensaje( )

Curso UML 72

DSS: Consulta en Línea

: Alumno : Sistema

: Profesor

solicitarCosulta(Profesor)

solicitarConsulta(Alumno)

aceptarConsulta( )

enviarMensaje(String)


terminarConsultaEnLinea( )


rechazarConsulta( )

Curso UML 73

Contratos: Consulta en Línea

• Nombre: solicitarConsulta (profesor: Profesor)• Responsabilidades: solicita al profesor una

consulta en línea• Tipo: GestorConsultas• Notas: acceso al GestorCentral y al Alumno a

través del Singleton• Postcondiciones:

– Objeto ConsultaEnLinea es creado

– Asociación ConsultaEnLinea-Profesor es creada

Curso UML 74


• Postcondiciones (continuación):– Asociación ConsultaEnLinea-Alumno es creada

– Asociaciones entre ConsultaEnLinea y Gestores de Consultas (profesor y alumno) son creadas

– Asociación GestorConsultas-OyenteConsultasEnLinea es creada

Curso UML 75

DI: solicitarConsulta : Alumno

gestorAlumno : GestorConsultas

nuevaConsultaEnLinea : ConsultaEnLinea

: GestorCentral

gestorProfesor : GestorConsultas

solicitudConsultaEnLinea(Profesor, OyenteConsultaEnLinea)

solicitarConsultaEnLinea(Alumno, Profesor, GestorConsultas)

solicitudConsultaEnLinea(ConsultaEnLinea)

create( )

setAlumno(Alumno)


setGestores(GestorConsultas, GestorConsultas)

getGestorProfesor(Profesor)

getAlumno( )

setOyente(OyenteConsultaEnLinea)

Curso UML 76


• Nombre: aceptarConsulta ()• Responsabilidades: notificar al alumno que la

consulta ha sido aceptada por el profesor• Tipo: GestorConsultas• Postcondiciones:

– Objeto Periodo es creado

– Asociación GestorConsultas-OyenteGestorConsultas es creada

– Asociación ConsultaEnLinea-Periodo es creada

Curso UML 77

DI: aceptarConsulta

profesor : Profesor

gestorAlumno : GestorConsultasAlumno



aceptarConsulta(OyenteConsultaEnLinea )

consultaAceptada( )

consultaAceptada(ConsultaEnLinea)

periodo : Periodo

create( )

setInicioPerido( )

setOyente(OyenteConsultaEnLinea)

Curso UML 78


• Nombre: rechazarConsulta ()• Responsabilidades: notificar al alumno que la

consulta ha sido rechazada por el profesor• Tipo: GestorConsultas• Postcondiciones:

– Objeto ConsultaEnLinea es destruido.

Curso UML 79

DI: rechazarConsulta


profesor : Profesor



rechazarConsulta( )

consultaRechazada( )

consultaRechazada( )

destroy( )

Curso UML 80


• Nombre: enviarMensaje (mensaje: String)• Responsabilidades: envía un mensaje al otro

interlocutor• Tipo: GestorConsultas

Curso UML 81

DI: enviarMensaje

: Alumno



: OyenteConsultaEnLinea

consultaEnLinea : ConsultaEnLinea


Este diagrama describe la secuencia de mensajes iniciada por el alumno. El diagrama para el profesor sería equivalente

Referencia al Gestor que realiza la llamada

enviarMensaje(String, GestorConsultas)

enviarMensaje(String)setMensaje(String)

Curso UML 82


• Nombre: terminarConsultaEnLinea ()• Responsabilidades: notifica al otro interlocutor

que la consulta ha finalizado y registra la consulta asociada al profesor


– Asociación Profesor-ConsultaEnLinea es creada.

Curso UML 83

DI: terminarConsultaEnLinea

profesor : Profesor : Alumno


: GestorCentral

: ConsultaEnLinea


: OyenteConsultaEnLinea

periodo : Periodo


terminarConsultaEnLinea(ConsultaEnLinea, GestorConsultas)

terminarConsultaEnLinea(GestorConsultas)

consultaEnLineaFinalizada( )

profesor := getProfesor( )

addConsultaEnLinea(ConsultaEnLinea)

setFinPeriodo( )

consultaFinalizada( )

Curso UML 84

DSS: Responder Consulta

: Profesor : Sistema

responderConsulta( )

Curso UML 85

Contratos: Responder Consulta

• Nombre: responderConsulta (consulta: Consulta, mensaje: String)

• Responsabilidades: crear una Respuesta y asociarla a la consulta


– Objeto Respuesta es creado

– Asociación consulta-Respuesta es creada

– consulta.estado = “respondida”

Curso UML 86

DI: responderConsulta

: Profesor

: GestorConsultas

nuevaRespuesta : Respuesta

consulta : Consulta

responderConsulta(Consulta, String)create(String)

setRespuesta(Respuesta)

Curso UML 87

DSS: Consultar Buzón Entrada Profesor




CDU Responder Consulta

Curso UML 88

Contratos: Consultar Buzón Entrada Profesor


• Responsabilidades: recordar la consulta seleccionada y devolver el contenido

• Tipo: BuzonProfesor• Postcondiciones:

– Asociación BuzonProfesor-consulta es creada

Curso UML 89


: Profesor :

BuzonProfesor : Consulta



getMensaje( )

Curso UML 90


• Nombre: responderConsulta (respuesta: String)• Responsabilidades: crear una respuesta y

asociarla a la consulta• Tipo: BuzonProfesor• Notas: Ver CDU “Responder Consulta”• Precondiciones: una consulta ha sido

seleccionada (seleccionarConsulta)

Curso UML 91


• Postcondiciones:– Objeto Respuesta es creado



Curso UML 92


: Profesor :

BuzonProfesor :

GestorConsultas

responderConsulta(String)

responderConsulta(Consulta, String)

CDU "Responder Consultas"

Consulta es un atributo de BuzonProfesor

Curso UML 93

DSS: Explorar Consultas Profesor



seleccionarAlumno( )

seleccionarTema( )



Curso UML 94

Contratos: Explorar Consultas Profesor

• Nombre: List(Alumno) seleccionarAsignatura (asignatura: Asignatura)

• Responsabilidades: recordar la asignatura y devolver los alumnos matriculados en ella

• Tipo: ExploradorProfesor• Postcondiciones:

– Asociación ExploradorProfesor-asignatura es creada

Curso UML 95


: ExploradorProfesor : Profesor

: Asignatura

seleccionarAsignatura(Asignatura)

getAlumnos( )

setAsignatura(Asignatura)

Curso UML 96


• Nombre: List(Tema) seleccionarAlumno (alumno: Alumno)

• Responsabilidades: recordar alumno seleccionado y mostrar sus temas de consulta


– Asociación ExploradorProfesor-alumno es creada

Curso UML 97

DI: seleccionarAlumno

: Profesor :

ExploradorProfesor : Alumno

seleccionarAlumno(Alumno)

getTemas(Asignatura, Profesor)

setAlumno(Alumno)

Curso UML 98


• Nombre: List(Consulta) seleccionarTema (tema: Tema)

• Responsabilidades: recordar el tema seleccionado y devolver las consultas asociadas


– Asociación ExploradorProfesor-tema es creada

Curso UML 99

DI: seleccionarTema

: Profesor :

ExploradorProfesor : Tema

seleccionarTema(Tema)

setTema(Tema)

getConsultas( )

Curso UML 100



• Responsabilidades: recordar la consulta seleccionada y devolver su contenido


– Asociación ExploradorProfesor-consulta es creada

Curso UML 101


: Profesor :

ExploradorProfesor : Consulta



getMensaje( )

Curso UML 102


• Nombre: responderConsulta (respuesta: String)• Responsabilidades: crear una respuesta y

asociarla a la consulta• Tipo: ExploradorAlumno• Notas: ver CDU “Responder Consulta”• Precondiciones: una consulta ha sido

seleccionada (seleccionarConsulta)

Curso UML 103


• Postcondiciones:– Objeto Respuesta es creado



Curso UML 104


: Profesor :

ExploradorProfesor :

GestorConsultas

responderConsulta(Respuesta)

responderConsulta(Consulta, String)

CDU "Responder Consultas"

El Explorador posee una referencia a la consulta seleccionada

Curso UML 105

DSS: Establecer Tutorías



setAsignaturaEnTutoria( )

setAsignaturaSinTutoria( )

Curso UML 106

Contratos: Establecer Tutorías

• Nombre: seleccionarAsignatura (asignatura: TutoriaAsignatura)

• Responsabilidades: recordar la asignatura seleccionada

• Tipo: GestorTutorias• Postcondiciones:

– Asociación GestorTutorias-asignatura es creada

Curso UML 107


: Profesor :

GestorTutorias

seleccionarAsignatura(TutoriaAsignatura)

setAsignatura(TutoriaAsignatura)

Curso UML 108


• Nombre: setAsignaturaEnTutoria (asignatura: TutoriaAsignatura)

• Responsabilidades: establecer que un profesor está en tutorías de una asignatura

• Tipo: GestorTutorías• Postcondiciones:

– Si no estaba en tutorías de la asignatura:• Objeto Perido es creado

• PeridoTutoria.horaInicio = horaActual

• Asociación TutoriaAsignatura-Periodo (periodoActual)

Curso UML 109

DI: setAsignaturaEnTutoria

asignatura : TutoriaAsignatura : Profesor

: GestorTutorias

nuevoPeriodoTutoria : Periodo

setAsignaturaEnTutoria( )

setEnTutoria( )

enTutoria := estaEnTutoria( )

[enTutoria]

create( )

setInicioPerido( )

setPeridoActual(PeriodoTutoria)

Curso UML 110


• Nombre: setAsignaturaSinTutoria (asignatura: TutoriaAsignatura)

• Responsabilidades: establecer que un profesor no está en tutorías de una asignatura

• Tipo: GestorTutorías• Postcondiciones:

– Si estaba en tutorías de la asignatura:• TutoriaAsignatura.periodoActual.horaFin = horaActual

• Asociación TutoriaAsignatura-Periodo es creada (periodos)

Curso UML 111

DI: setAsignaturaSinTutoria

: Profesor :

GestorTutoriasasignatura :

TutoriaAsignaturaperiodoActual :

Periodo

setAsignaturaSinTutoria( )

setSinTutoria( )

enTutoria := estaEnTutoria( )

[not enTutoria]

setFinPeriodo( )

addPeriodoTutoria(PeriodoTutoria)

Curso UML 112

DSS: Identificación Alumno

: Alumno : Sistema

identificacionAlumno( )

Curso UML 113

Contratos: Identificación Alumno

• Nombre: Alumno identificacionAlumno (pin: PIN)

• Responsabilidades: validar y obtener la identificación del Alumno

• Tipo: GestorIdentificacion• Notas: acceso al gestor central utilizando el

Singleton• Excepciones: PINIncorrecto, AlumnoNoExiste

Curso UML 114

DI: identificacionAlumno

: Profesor :

GestorCentral : Tarjetero :

GestorIdentificacion

identificacionAlumno(PIN)

ok := comprobarPIN(PIN)

getAlumno(DNI)

dni := getDNI( )

[not ok]

Excepcion

Curso UML 115

DSS: Identificación Profesor


identificacionProfesor( )

Curso UML 116

Contratos: Identificación Profesor

• Nombre: Profesor identificacionAlumno (pin: PIN)

• Responsabilidades: validar y obtener la identificación del Profesor

• Tipo: GestorIdentificacion• Notas: acceso al gestor central utilizando el

Singleton• Excepciones: PINIncorrecto, ProfesorNoExiste

Curso UML 117

DI: identificacionProfesor

: GestorIdentificacion : Profesor

: Tarjetero : GestorCentral

identificacionProfesor(PIN)

ok := comprobarPIN(PIN)

[not ok]

dni := getDNI( )

getProfesor(DNI)Excepción

Curso UML 118

Aplicación Patrones GRASP

• ¿Se ha violado algún patrón GRASP en los anteriores diagramas de interacción?

• Sí. La clase GestorConsultas no está cohesionada:– Incluye funcionalidad para el Alumno

– Incluye funcionalidad para el Profesor

• Solución: crear dos gestores de consultas:– GestorConsultasAlumno

– GestorConsultasProfesor

Curso UML 119

Visibilidad

• Visibilidad: capacidad de un objeto para hacer referencia a otro

• Tipos:– Visibilidad de atributos: declarada mediante

asociaciones

– Visibilidad de parámetros: utilizar dependencias

– Visibilidad local: declaración local• Durante el análisis/diseño es difícil identificarla

– Visibilidad global: utilizar dependencias• Clases Singleton y objetos que obtenemos a partir de ellas. En

nuestro ejemplo los objetos Controlador

Curso UML 120

Arranque del Sistema

• El arranque del sistema es un aspecto que hay que tener en cuenta.

• Durante el arranque se crean objetos y asociaciones entre ellos

• Nuestro sistema está dividido en 3 partes:– Aplicación Alumno

– Aplicación Profesor

– Servidor Central (Gestor Central)

Curso UML 121


• Las aplicaciones del alumno y profesor deben:– Validar la identidad del usuario.

– Obtener un objeto que los identifique.

• El objeto que identifica a los usuarios es conveniente que sea accesible de forma global (patrón Singleton).

• Ambas aplicaciones comenzaran validando a los usuarios. Si este proceso falla, no continuará la aplicación.

Curso UML 122


• También hay que tener en cuenta las operaciones que demandan las interfaces durante la creación:– Consultar Buzón Entrada Alumno:

• getConsultasNoLeidas

– Explorar Consultas Alumno:• getAsignaturasMatriculado

– Consulta en línea:• getProfesoresEnLinea

– Consultar Buzón Entrada Profesor:• getConsultasNoRespondidas

– Explorar Consultas Profesor:• getAsignaturasProfesor

Curso UML 123

Contrato: Consultar Buzón Entrada Alumno

• Nombre: List (Consulta) getConsultasNoLeidas()• Responsabilidades: obtener las consultas no

leídas para un determinado alumno• Tipo: BuzonAlumno• Notas: acceso al Alumno a través del Singleton

Curso UML 124

DI: getConsultasNoLeidas

: BuzonAlumno : Alumno alumno : Alumno

: Tema consulta : Consulta

getConsultasNoLeidas( )

getConsultasNoLeidas( )

Para cada Tema del Alumno:

consultas := getConsultas( )

Para cada consulta en consultas:

leida := estaLeida( )

if (not leida) resultado.add(consulta)

resultado

resultado := create Coleccion()

Curso UML 125


• Nombre: List (Asignatura) getAsignaturasMatriculado ()

• Responsabilidades: devolver las asignaturas en las que esta matriculado el alumno

• Tipo: ExploradorAlumno• Notas: acceso a Alumno a través del Singleton

Curso UML 126

DI: getAsignaturasMatriculado

: Alumno

: ExploradorAlumno

alumno : Alumno

getAsignaturasMatriculado( )

getAsignaturas( )

Curso UML 127

Contratos: Consulta En Línea

• Nombre: List (Profesores) getProfesoresEnLinea ()

• Responsabilidades: devolver una colección con los profesores que están disponibles para una consulta

• Tipo: GestorConsultasAlumno• Notas: acceso a Alumno a través del Singleton

Curso UML 128

DI: getProfesoresEnLinea

: GestorConsultasAlumno

: Alumno profesor : Profesor

asignatura : Asignaturaalumno : Alumno

getProfesoresEnLinea( )

asignaturas := getAsignaturas( )

Para cada asignatura en asignaturas:

profesoresEnLinea = create Coleccion()

profesores := getProfesores( )

Para cada profesor en profesores:

enLinea := estaEnLinea( )

if (enLinea) profesoresEnLinea.add(profesor)profesoresEnLinea

Curso UML 129

Contratos: Consultar Buzón Entradas Profesor

• Nombre: List (Consulta) getConsultasNoRespondidas()

• Responsabilidades: devolver una colección con las consultas no respondidas por el profesor

• Tipo: BuzonProfesor• Notas: acceso a Profesor a través del Singleton

Curso UML 130

DI: getConsultasNoRespondidas

: Profesor :

BuzonProfesor profesor : Profesor

asignatura : Asignatura

alumno : Alumnotema : Tema consulta :

Consulta

getConsultasNoRespondidas( )

asignaturas := getAsignaturas( )

alumnos := getAlumnos( )

temas := getTemas(Asignatura, Profesor)

consultas := getConsultas( )

consultasNoRespondidas := create Coleccion()

Para cada asignatura en Asignaturas:

Para cada alumno en Alumnos:

Para cada consulta en consultas:

Para cada tema en Temas:

respondida := estaRespondida( )

if (not respondida) consultasNoRespondidas.add(consulta)

consultasNoRespondidas

Curso UML 131


• Nombre: List (Asignatura) getAsignaturasProfesor()

• Responsabilidades: devolver las asignaturas que imparte el profesor

• Tipo: ExplorarProfesor• Notas: acceso a Profesor a través del Singleton

Curso UML 132

DI: getAsignaturasProfesor

: Profesor :

ExploradorProfesor profesor : Profesor

getAsignaturasProfesor( )

getAsignaturas( )

Curso UML 133

Organización en Paquetes

• Conviene organizar las clases en paquetes.• En nuestra aplicación, para las clases del modelo

creamos 4 paquetes:– Alumno

– Profesor

– Comun

– Universidad

• Creamos un paquete más para las interfaces gráficas, pantallas, que a su vez contiene los paquetes PAlumno, PProfesor y PComun.

Curso UML 134

Organización en Paquetes

• Paquetes del modelo: (incluye clases controlador)– Alumno: Alumno, GestorAlumno, BuzonAlumno,

ExploradorAlumno

– Profesor: Profesor, TutoriaAsignatura, HorarioTutorias, FranjaHoraria, GestorProfesor, BuzonProfesor, ExploradorProfesor, GestorTutorias

– Universidad: Asignatura, Tarjetero, GestorCentral, GestorIdentificacion

– Común: Consulta, Tema, Respuesta, ConsultaEnLinea, GestorConsultas, Periodo

Curso UML 135

Diagramas Controladores

• Creamos un diagrama de clases para mostrar las asociaciones y dependencias de las clases controlador.

• Dos diagramas:– Diagrama Controladores Alumno

– Diagrama Controladores Profesor

Curso UML 136

Alumno

GestorCentral(from Universidad)

ConsultaEnLinea(from Comun)

Tema(from Comun)

Profesor

(from Profesor)

Tarjetero

comprobarPIN()getDNI()getInstancia()

(from Universidad)

<<Singleton>>

0..1

-instancia

0..1

Consulta(from Comun)

Consulta(from Comun)


Profesor

(from Profesor)

Tema(from Comun)

BuzonAlumno

marcarConsultaLeida()getConsultasNoLeidas()

<<controlador>>

0..1

-consulta

0..1

ExploradorAlumno

seleccionarAsignatura()seleccionarProfesor()setProfesor()getAsignaturasMatriculado()

<<controlador>>

0..1

-consulta

0..1

0..1-asignatura

0..1

0..1

-profesor

0..1

0..1

-tema

0..1

GestorCentral

terminarConsultaEnLinea()solicitarConsultaEnLinea()getGestorProfesor()asignaturaEnTutoria()getAlumno()getProfesor()GestorCentral()

(from Universidad)

GestorIdentificacion

identificacionAlumno()identificacionProfesor()

(from Universidad)

<<controlador>>

GestorConsultasAlumno

nuevaConsulta()nuevoTema()solicitudConsultaEnLinea()consultaAceptada()consultaRechazada()getProfesoresEnLinea()

<<controlador>>

GestorAlumno

getInstancia()getExplorador()getGestorConsultas()getBuzon()getGestorCentral()getGestorIdentificacion()getAlumno()

(from GestorConsultasAlumno)

<<Singleton>> 1

-buzon

1

1

-explorador

1

0..1

-instancia

0..1

1

-gestorCentral

1

0..1

-gestorIdentificacion

0..1

1-gestorConsultas

1

Alumno


Profesor

(from Profesor)

Curso UML 137

TutoriaAsignatura

BuzonProfesor

responderConsulta()getConsultasNoRespondidas()

<<controlador>>

ExploradorProfesor

seleccionarAsignatura()seleccionarAlumno()setAlumno()getAsignaturasProfesor()

<<controlador>>

GestorCentral

terminarConsultaEnLinea()solicitarConsultaEnLinea()getGestorProfesor()asignaturaEnTutoria()getAlumno()getProfesor()GestorCentral()

(from Universidad)

GestorTutorias

seleccionarAsignatura()setAsignatura()setAsignaturaEnTutoria()setAsignaturaSinTutoria()

<<controlador>>

0..1

-asignatura

0..1

GestorConsultasProfesor

aceptarConsulta()rechazarConsulta()responderConsulta()

<<controlador>>

GestorProfesor

getGestorTutorias()getInstancia()getExplorador()getGestorConsultas()getBuzon()getGestorCentral()getGestorIdentificacion()getProfesor()

<<Singleton>>

1-buzon

1

1

-explorador

1

0..1

-instancia

0..1

1-gestorCentral

1

1

-gestorTutorias

1

1-gestorConsultas

1

ConsultaEnLinea(from Comun)



<<controlador>>

Alumno

(from Alumno)

Tema(from Comun)


Consulta(from Comun)0..1

-consulta

0..1

0..1

-consulta

0..1

Alumno

(from Alumno)

0..1

-alumno

0..1

Tema(from Comun)

0..1

-tema

0..1


0..1

-asignatura

0..1

Profesor

Curso UML 138

Diagrama de Clases

• En el diagrama de clases nos aparecen sólo los conceptos del modelo conceptual que hayan intervenido en los diagramas de interacción.

• Incluímos los métodos de las clases.• Añadimos a las asociaciones la navegabilidad,

cardinalidades, roles, agregación, ....

Curso UML 139

FranjaHoraria

inicio : Timefin : Timedia : Day

(from Profesor)

Profesor

(from Profesor)

HorarioTutorias

/ numeroHoras : Integer

(from Profesor)

1

-franjasHorarias

1

Asignatura

codigo : Stringnombre : String

getProfesores()getAlumnos()

(from Universidad)

1..*

1..*

-asignaturas 1..*

-profesores1..*

imparte

Profesor

addConsultaEnLinea()estaEnLinea()

getAsignaturas()

(from Profesor)

1-horarioTutorias

1

tiene

Alumno

addTema()getTemas()

getConsultasNoLeidas()getAsignaturas()

(from Alumno)1..*

1..*

-alumnos

1..*

-asignaturas

1..*

matriculado en

0..* 0..*

+alumno

0..*

+profesor

0..*tutoria en linea

Tema

nombre : String

addConsulta()create()setProfesor()setAsignatura()getConsultas()

(from Comun)

profesor : Profesorasignatura : Asignatura

1

0..*

1

profesor : Profesorasignatura : Asignatura

-temas 0..*

organiza consultas por

Consulta

titulo : Stringfecha : Datehora : Timemensaje : Stringestado : String

create()setTitulo()setMensaje()getMensaje()setLeido()setRespuesta()estaLeida()estaRespondida()

(from Comun)

0..*

1 -consultas

0..*

1

contiene

Respuesta

mensaje : Stringfecha : Datehora : Time

create()

(from Comun)

1 0..11

-respuesta

0..1

TutoriaAsignatura

estaEnTutoria()setEnTutoria()setPeridoActual()setSinTutoria()addPeriodoTutoria()

(from Profesor)

GestorConsultas(from Comun)

<<controlador>>

Periodo

inicio : Timefin : Time

create()setInicioPerido()setFinPeriodo()

(from Comun)

0..*

1

-periodos

0..*

1

ConsultaEnLinea

terminarConsultaEnLinea()getProfesor()create()setAlumno()setProfesor()setGestores()getAlumno()getGestorAlumno()enviarMensaje()destroy()consultaAceptada()consultaRechazada()

(from Comun)

1-gestorAlumno

1

1-gestorProfesor

10..1

-periodo

0..1

Curso UML 140

Herencia

• Hasta ahora no hemos tenido en cuenta la herencia.

• En nuestra aplicación surge la necesidad de la herencia con las clases controlador:– ExploradorAlumno-ExploradorProfesor

– BuzonAlumno-BuzonProfesor

– GestorConsultasAlumno-GestorConsultasProfesor

– GestorAlumno-GestorProfesor Factorizar comportamiento común

• También con Alumno y Profesor

Curso UML 141

Herencia

• Aparecen nuevas clases:– Explorador

– Buzon

– GestorConsultas

– Gestor

– Universitario

• Las clases que teníamos serán subtipos de estas últimas

Curso UML 142

Alumno

addTema()getTemas()

getConsultasNoLeidas()getAsignaturas()

(from Alumno)

GestorConsultas

enviarMensaje()terminarConsultaEnLinea()consultaEnLineaFinalizada()setOyente()

(from Comun)

<<controlador>>Explorador

seleccionarAsignatura()setAsignatura()seleccionarConsulta()setConsulta()seleccionarTema()setTema()

(from Comun)

<<controlador>>

Buzon

seleccionarConsulta()setConsulta()

(from Comun)

<<controlador>>

Gestor

getInstancia()getExplorador()getGestorConsultas()getBuzon()getGestorCentral()getGestorIdentificacion()

(from Comun)

BuzonProfesor

responderConsulta()getConsultasNoRespondidas()

(from Profesor)

<<controlador>>



(from Profesor)

<<controlador>>

GestorProfesor

getGestorTutorias()getInstancia()getExplorador()getGestorConsultas()getBuzon()getGestorCentral()getGestorIdentificacion()getProfesor()

(from Profesor)

<<Singleton>>BuzonAlumno

marcarConsultaLeida()getConsultasNoLeidas()

(from Alumno)

<<controlador>>

GestorConsultasAlumno

nuevaConsulta()nuevoTema()solicitudConsultaEnLinea()consultaAceptada()consultaRechazada()getProfesoresEnLinea()

(from Alumno)

<<controlador>>

GestorAlumno

getInstancia()getExplorador()getGestorConsultas()getBuzon()getGestorCentral()getGestorIdentificacion()getAlumno()

(from GestorConsultasAlumno)

<<Singleton>>

Universitario


(from Universidad)

ExploradorAlumno

seleccionarAsignatura()seleccionarProfesor()setProfesor()getAsignaturasMatriculado()

(from Alumno)

<<controlador>>ExploradorProfesor

seleccionarAsignatura()seleccionarAlumno()setAlumno()getAsignaturasProfesor()

(from Profesor)

<<controlador>>

Profesor

addConsultaEnLinea()estaEnLinea()

getAsignaturas()

(from Profesor)

Curso UML 143

Pantallas

• Las interfaces de usuario están relacionadas• Poseen una relación de creación• Las interfaces utilizan un controlador

(dependencia)• Es conveniente mostrar un diagrama que contenga

estas relaciones

Curso UML 144

Pantallas: Alumno

PBuzonAlumno

PSolicitudConsulta

PNuevoTema

PConsulta

PPrincipal

<<create>>

PExploradorAlumno

<<create>>

<<create>>

<<create>><<create>>

GestorConsultasAlumno(from Alumno)

<<controlador>>

ExploradorAlumno(from Alumno)

<<controlador>>

BuzonAlumno(from Alumno)

<<controlador>>

GestorAlumno(from Alumno)

<<Singleton>>

Todas las pantallas tienen una relación de dependencia con el Singleton

Curso UML 145

Pantallas Alumno

PExploradorProfesor

PEstablecerTutorias

PBuzonProfesor

PRespuesta

PPrincipal

BuzonProfesor(from Profesor)

<<controlador>>

ExploradorProfesor(from Profesor)

<<controlador>>

GestorTutorias(from Profesor)

<<controlador>>

GestorConsultasProfesor(from Profesor)

<<controlador>>

GestorProfesor(from Profesor)

<<Singleton>>

<<create>>

<<create>>

<<create>>

<<create>>

<<create>>

PAceptarConsulta

Todas las pantallas tienen una relación de dependencia con el Singleton

Curso UML 146

Distribución

• La mayor parte de los objetos de la aplicación necesitan ser distribuidos.

• Para conseguir la distribución de los objetos utilizaremos CORBA

• Necesitamos definir las interfaces CORBA para los objetos.

• Modificaciones: definir interfaces CORBA y las clases renombrarlas con el sufijo Impl.

Curso UML 147

Distribución

ConsultaEnLineaImpl

terminarConsultaEnLinea()getProfesor()create()

setAlumno()setProfesor()setGestores()getAlumno()getGestorAlumno()enviarMensaje()destroy()consultaAceptada()consultaRechazada()

(from Comun)

ConsultaEnLinea

terminarConsultaEnLinea()getProfesor()setAlumno()setProfesor()setGestores()getAlumno()

enviarMensaje()consultaAceptada()

consultaRechazada()

Curso UML 148

Codificación

• Con la herramienta Rational Rose podemos generar código a partir de los diagramas de clases. Lenguajes: Java, C++, Visual Basic, IDL,...

• Genera todo el código excepto la implementación de los métodos.

• Permite conectar la herramienta con cualquier IDE del lenguaje de programación utilizado.

• Ingeniería Inversa: cualquier modificación en el código se verá reflejada en el modelo

• Round Trip Engineering.

Curso UML 149

Fin Primer Ciclo Desarrollo

• Es recomendable realizar un proceso de desarrollo iterativo e incremental

• Al final de cada fase obtenemos un producto totalmente funcional (con simplificaciones)

• Temas pendientes:– Realizar los cálculos necesarios para la universidad:

porcentaje de cumplimiento de tutorías, consultas respondidas, etc.

– Distribución– Persistencia– ...

Curso UML 150

Persistencia

• La mayor parte de los objetos de la aplicación deben ser persistentes.– Los controladores no deben ser persistentes

• Alternativas:– Utilizar un servidor de aplicaciones Enterprise

JavaBeans.• La mayor parte de los objetos serían EJB Entity (persistentes)

• Modificaciones en el diseño:– Creación, localización y destrucción de los objetos utilizando las

interfaces home.

– Framework de persistencia basado en CORBA

Curso UML 151

Persistencia

• Framework de persistencia basado en CORBA:– En nuestro sistema existe un servidor CORBA

– Definimos interfaces home para los objetos CORBA

– Modificación en el diseño:• Creación, localización y destrucción de los objetos utilizando

las interfaces home.

Curso UML 152

Diagrama de Despliegue

Ordenador Alumno

Ordenador Profesor

Servidor Central

<<CORBA>>

InternetInternet

Internet

<<ORB>>

<<ORB>><<ORB>>

Curso UML 153

Componentes

• Cuando modelemos una aplicación debemos pensar en los componentes.

• En nuestra aplicación podemos identificar algunos componentes reutilizables. Por ejemplo, el Buzón.

• Lo ideal sería desarrollar un componente gráfico Buzón que fuera reutilizable.– En nuestra aplicación los buzones tienen un Director

que indicará los elementos a listar.

– Los elementos de la lista deben tener un Descriptor y un Contenido.

Curso UML 154

Componentes

• Definimos dos interfaces (en Java):– IDirectorBuzon

• String [] etiquetas ()

• IElementoBuzon [] elementos ()

– IElementoBuzon• String [] descriptor ()

• String contenido ()

• Nuestro componente tendrá la siguiente interface:– void setDirector (IDirectorBuzon)

– IElementoBuzon getElementoSeleccionado ()

Curso UML 155

Componentes

• Desarrollaremos un interfaz gráfico basado en los componentes Swing de Java:

IBuzon

setDirector()getElementoSeleccionado()

IElementoBuzon

descriptor()contenido()

IDirectorBuzon

etiquetas()elementos()

JScrollPane(from Swing)

JPane(from Swing)

JTable(from Swing)

JTextArea(from Swing)

BuzonGrafico

0..*1

11

1

1

-elementos

0..*-director

1

-contenido

1

-descriptores

1-scrollpane1

-panel

1

BuzonGrafico

IBuzon

ingeniería de software ii información obtenida de internet universidad de san martin de porres...

Documents