Nombre: Sergio Saavedra Galvez
Numero de Control: 2021632
Carrera: Ing. en Sistemas Computacionales
Materia: Patrones de Diseño de Software
classDiagram
class Usuario {
- nombre: string
- correoElectronico: string
- contraseña: string
- tipoUsuario: string
+ gestionarCuenta()
+ autenticar()
+ actualizarPerfil()
}
class Proyecto {
- titulo: string
- descripcion: string
- contenidoMultimedia: string
- estadoProyecto: string
- fechaCreacion: date
- colaboradores: string[]
+ gestionarProyectos()
+ añadirColaboradores()
+ actualizarDetalles()
+ finalizarProyecto()
}
class Colaboracion {
- rolColaborador: string
- contribucionEspecifica: string
- estadoColaboracion: string
+ gestionarInteraccion()
+ enviarMensajes()
+ compartirArchivos()
+ coordinarTareas()
}
class EvaluacionProyecto {
- calificacionesProyectos: number[]
- comentariosUsuarios: string[]
- metricasValoracion: string
+ recopilarRetroalimentacion()
+ visualizarRetroalimentacion()
}
class BusquedaProyecto {
+ buscarProyectos()
}
class Administrador {
+ gestionarUsuarios()
+ gestionarProyectos()
+ gestionarColaboraciones()
+ gestionarEvaluaciones()
+ operacionesAdministrativas()
}
Usuario --|> Proyecto
Usuario --|> Colaboracion
Proyecto --|> Colaboracion
Usuario --|> EvaluacionProyecto
Proyecto --|> EvaluacionProyecto
Usuario --|> BusquedaProyecto
Proyecto --|> BusquedaProyecto
Administrador --|> Usuario
Administrador --|> Proyecto
Administrador --|> Colaboracion
Administrador --|> EvaluacionProyecto
from typing import List
class Usuario:
def __init__(self, nombre: str, correo_electronico: str, contraseña: str, tipo_usuario: str):
self.nombre = nombre
self.correo_electronico = correo_electronico
self.contraseña = contraseña
self.tipo_usuario = tipo_usuario
def gestionar_cuenta(self):
# Lógica para gestionar la cuenta del usuario
pass
def autenticar(self):
# Lógica para autenticar al usuario
pass
def actualizar_perfil(self):
# Lógica para actualizar el perfil del usuario
pass
class Proyecto:
def __init__(self, titulo: str, descripcion: str, contenido_multimedia: str, estado_proyecto: str, fecha_creacion: str, colaboradores: List[str]):
self.titulo = titulo
self.descripcion = descripcion
self.contenido_multimedia = contenido_multimedia
self.estado_proyecto = estado_proyecto
self.fecha_creacion = fecha_creacion
self.colaboradores = colaboradores
def gestionar_proyectos(self):
# Lógica para gestionar los proyectos
pass
def añadir_colaboradores(self):
# Lógica para añadir colaboradores al proyecto
pass
def actualizar_detalles(self):
# Lógica para actualizar los detalles del proyecto
pass
def finalizar_proyecto(self):
# Lógica para finalizar el proyecto
pass
class Colaboracion:
def __init__(self, rol_colaborador: str, contribucion_especifica: str, estado_colaboracion: str):
self.rol_colaborador = rol_colaborador
self.contribucion_especifica = contribucion_especifica
self.estado_colaboracion = estado_colaboracion
def gestionar_interaccion(self):
# Lógica para gestionar la interacción entre colaboradores
pass
def enviar_mensajes(self):
# Lógica para enviar mensajes entre colaboradores
pass
def compartir_archivos(self):
# Lógica para compartir archivos entre colaboradores
pass
def coordinar_tareas(self):
# Lógica para coordinar tareas entre colaboradores
pass
class EvaluacionProyecto:
def __init__(self, calificaciones_proyectos: List[int], comentarios_usuarios: List[str], metricas_valoracion: str):
self.calificaciones_proyectos = calificaciones_proyectos
self.comentarios_usuarios = comentarios_usuarios
self.metricas_valoracion = metricas_valoracion
def recopilar_retroalimentacion(self):
# Lógica para recopilar retroalimentación sobre el proyecto
pass
def visualizar_retroalimentacion(self):
# Lógica para visualizar la retroalimentación sobre el proyecto
pass
class BusquedaProyecto:
def buscar_proyectos(self):
# Lógica para buscar proyectos
pass
class Administrador(Usuario):
def gestionar_proyectos(self):
# Lógica para que el administrador gestione proyectos
pass
def gestionar_colaboraciones(self):
# Lógica para que el administrador gestione colaboraciones
pass
def gestionar_evaluaciones(self):
# Lógica para que el administrador gestione evaluaciones de proyectos
pass
def operaciones_administrativas(self):
# Otras operaciones administrativas que pueda realizar el administrador
pass- Descripción: Esta clase representa a los usuarios de la plataforma.
- Atributos: Puede incluir nombre, correo electrónico, contraseña, tipo de usuario (artista, colaborador, administrador), entre otros.
- Funcionalidades: Métodos para la gestión de la cuenta, autenticación, actualización de perfil, etc.
- Descripción: Modela los proyectos artísticos creados en la plataforma.
- Atributos: Título, descripción, contenido multimedia, estado del proyecto, fecha de creación, colaboradores, etc.
- Funcionalidades: Métodos para gestionar proyectos, como añadir colaboradores, actualizar detalles y finalizar el proyecto.
- Descripción: Representa la relación entre los usuarios en un proyecto específico.
- Atributos: Rol de cada colaborador, contribución específica, estado de la colaboración, etc.
- Funcionalidades: Métodos para gestionar la interacción entre colaboradores, como enviar mensajes, compartir archivos y coordinar tareas.
- Descripción: Gestiona la evaluación y calificación de proyectos por parte de los usuarios.
- Atributos: Calificaciones de proyectos, comentarios de usuarios, métricas de valoración, etc.
- Funcionalidades: Recopilación y visualización de la retroalimentación de los usuarios sobre los proyectos.
- Descripción: Realiza búsquedas de proyectos dentro de la plataforma.
- Funcionalidades: Permite a los usuarios buscar proyectos por palabras clave, tipo de proyecto, ubicación, habilidades, etc.
- Descripción: Representa a los usuarios con privilegios administrativos en la plataforma.
- Funcionalidades: Gestión de usuarios, proyectos, colaboraciones, evaluaciones y otras operaciones administrativas necesarias para el funcionamiento de la plataforma.
Dado el contexto del proyecto de la Plataforma Web para la Co-creación de Proyectos Artísticos y considerando las funcionalidades descritas, así como la necesidad de un sistema robusto y escalable, te recomendaría utilizar Python como lenguaje de programación principal para el backend y JavaScript para el desarrollo del frontend. Aquí tienes algunas razones para esta recomendación:
-
Facilidad de Uso: Python es conocido por su sintaxis clara y legible, lo que facilita el desarrollo y la mantenibilidad del código.
-
Amplia Disponibilidad de Bibliotecas y Frameworks: Python cuenta con una amplia variedad de bibliotecas y frameworks que pueden acelerar el desarrollo del backend. Por ejemplo, Django y Flask son frameworks populares que ofrecen características robustas y herramientas para el desarrollo web.
-
Escalabilidad: Python es adecuado para proyectos de gran escala y alta demanda debido a su capacidad para gestionar un gran número de solicitudes concurrentes.
-
Comunidad Activa: Python tiene una gran comunidad de desarrolladores que contribuyen constantemente con bibliotecas, frameworks y recursos útiles, lo que facilita la resolución de problemas y el desarrollo colaborativo.
-
Interactividad: JavaScript es fundamental para la creación de interfaces de usuario interactivas y dinámicas, lo que es crucial para una plataforma web moderna y atractiva.
-
Frameworks Frontend Populares: Existen numerosos frameworks y bibliotecas de JavaScript, como React.js, Angular.js y Vue.js, que pueden simplificar el desarrollo del frontend y proporcionar una estructura organizada para la interfaz de usuario.
-
Compatibilidad con Navegadores: JavaScript es el lenguaje de programación principal en el navegador web, lo que garantiza una amplia compatibilidad y un rendimiento óptimo en una variedad de dispositivos y navegadores.
-
Ecosistema en Expansión: El ecosistema de JavaScript está en constante crecimiento, con nuevas herramientas y tecnologías que se desarrollan continuamente para mejorar la experiencia de desarrollo web.
Al utilizar Python para el backend y JavaScript para el frontend, tendrás acceso a las fortalezas de ambos lenguajes y podrás construir una plataforma web potente, escalable e interactiva para la Co-creación de Proyectos Artísticos.
Se podría aplicar el patrón Singleton en la clase que gestiona la autenticación de usuarios para garantizar que solo exista una instancia de esta clase y proporcionar un punto de acceso global a esta instancia desde cualquier parte del sistema.
classDiagram
class Singleton {
- instance: Singleton
- constructor()
+ getInstance(): Singleton
}
Podría utilizarse un patrón Factory Method para crear instancias de objetos de diferentes tipos de usuarios (artista, colaborador, administrador) según la información proporcionada durante el proceso de registro.
classDiagram
class FactoryMethod {
+ factoryMethod(): Product
}
class Product {
+ operation()
}
La clase EvaluacionProyecto podría actuar como un sujeto observable que notifica a los observadores (usuarios interesados) sobre cambios en la retroalimentación de proyectos.
classDiagram
class Observer {
+ update()
}
class Subject {
+ attach(observer: Observer)
+ detach(observer: Observer)
+ notify()
}
En la clase de búsqueda de proyectos, podría aplicarse el patrón Strategy para permitir que los usuarios elijan diferentes estrategias de búsqueda, como búsqueda por palabras clave, tipo de proyecto, ubicación, habilidades, etc.
classDiagram
class Context {
- strategy: Strategy
+ setStrategy(strategy: Strategy)
+ executeStrategy()
}
class Strategy {
+ algorithmInterface()
}
Context --> Strategy
Podría utilizarse el patrón Composite para representar la estructura jerárquica de los proyectos artísticos, donde un proyecto puede contener subproyectos o componentes multimedia.
classDiagram
class Component {
+ operation()
}
class Composite {
- children: List<Component>
+ add(component: Component)
+ remove(component: Component)
+ getChild(index: int): Component
}
class Leaf {
+ operation()
}
Component <|-- Composite
Component <|-- Leaf
El patrón MVC podría aplicarse para separar la lógica de negocios (Modelo), la presentación (Vista) y el control de la interacción del usuario (Controlador), lo que facilitaría la gestión y mantenimiento del sistema.
classDiagram
class Model {
+ getData()
+ setData(data)
}
class View {
+ display(data)
}
class Controller {
- model: Model
- view: View
+ updateView()
}
Model <-- Controller
View <-- Controller
Podría aplicarse el patrón Decorator para agregar funcionalidades adicionales dinámicamente a las clases existentes, como la capacidad de evaluar proyectos, sin modificar su estructura básica.
classDiagram
class Component {
+ operation()
}
class ConcreteComponent {
+ operation()
}
class Decorator {
- component: Component
+ operation()
}
class ConcreteDecorator {
+ operation()
}
Component <|.. ConcreteComponent
Component <|.. Decorator
Decorator <|-- ConcreteDecorator
Se podría utilizar un patrón Proxy para controlar el acceso a los objetos de la clase Proyecto, por ejemplo, para restringir ciertas operaciones solo a usuarios autorizados.
classDiagram
class Subject {
+ request()
}
class RealSubject {
+ request()
}
class Proxy {
- realSubject: RealSubject
+ request()
}
Subject <|.. RealSubject
Subject <|.. Proxy
class Administrador:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
# Inicializar aquí los atributos del administrador
return cls._instanceclass EvaluacionProyecto:
def __init__(self):
self.calificacionesProyectos = []
self.comentariosUsuarios = []
self.metricasValoracion = ""
def agregar_calificacion(self, calificacion):
self.calificacionesProyectos.append(calificacion)
# Notificar a los observadores sobre la nueva calificaciónclass Colaboracion:
def __init__(self, estrategia):
self.estrategia = estrategia
def coordinar_tareas(self):
self.estrategia.coordinar()
class EstrategiaCoordinacion:
def coordinar(self):
pass
class EstrategiaCoordinacionSimple(EstrategiaCoordinacion):
def coordinar(self):
# Implementación de la estrategia simple de coordinación de tareas
pass
class EstrategiaCoordinacionAvanzada(EstrategiaCoordinacion):
def coordinar(self):
# Implementación de la estrategia avanzada de coordinación de tareas
passclass Proyecto:
def __init__(self, titulo, descripcion):
self.titulo = titulo
self.descripcion = descripcion
self.subproyectos = []
def agregar_subproyecto(self, subproyecto):
self.subproyectos.append(subproyecto)# Clase Modelo
class Modelo:
def __init__(self):
self.usuarios = []
self.proyectos = []
self.colaboraciones = []
self.evaluaciones_proyectos = []
def agregar_usuario(self, usuario):
self.usuarios.append(usuario)
def agregar_proyecto(self, proyecto):
self.proyectos.append(proyecto)
def agregar_colaboracion(self, colaboracion):
self.colaboraciones.append(colaboracion)
def agregar_evaluacion_proyecto(self, evaluacion):
self.evaluaciones_proyectos.append(evaluacion)
def obtener_usuarios(self):
return self.usuarios
def obtener_proyectos(self):
return self.proyectos
def obtener_colaboraciones(self):
return self.colaboraciones
def obtener_evaluaciones_proyectos(self):
return self.evaluaciones_proyectos
# Uso del Modelo
modelo = Modelo()
# Agregar usuarios, proyectos, colaboraciones y evaluaciones
usuario1 = Usuario("Usuario1", "usuario1@example.com", "contraseña123", "artista")
modelo.agregar_usuario(usuario1)
proyecto1 = Proyecto("Proyecto1", "Descripción del proyecto 1", "Contenido multimedia", "En progreso")
modelo.agregar_proyecto(proyecto1)
colaboracion1 = Colaboracion("Artista", "Contribución específica", "En curso")
modelo.agregar_colaboracion(colaboracion1)
evaluacion1 = EvaluacionProyecto([4, 5, 3], ["Buen proyecto", "Excelente trabajo"], "Métricas de valoración")
modelo.agregar_evaluacion_proyecto(evaluacion1)
# Obtener datos del modelo
print("Usuarios:", modelo.obtener_usuarios())
print("Proyectos:", modelo.obtener_proyectos())
print("Colaboraciones:", modelo.obtener_colaboraciones())
print("Evaluaciones de Proyectos:", modelo.obtener_evaluaciones_proyectos())class UsuarioDecorator:
def __init__(self, usuario):
self.usuario = usuario
def gestionar_cuenta(self):
# Lógica adicional antes de gestionar la cuenta
self.usuario.gestionar_cuenta()
# Lógica adicional después de gestionar la cuenta
# Implementación concreta de un decorador
class ValidadorUsuario(UsuarioDecorator):
def gestionar_cuenta(self):
# Lógica de validación de datos antes de gestionar la cuenta
super().gestionar_cuenta()
# Lógica adicional después de gestionar la cuenta
# Uso de los patrones en el contexto de las clases del sistema
admin1 = Administrador()
admin2 = Administrador()
print(admin1 is admin2) # Devuelve True, ya que solo hay una instancia de Administrador
evaluacion = EvaluacionProyecto()
evaluacion.agregar_calificacion(5) # Agregar una calificación y notificar a los observadores
colaboracion_simple = Colaboracion(EstrategiaCoordinacionSimple())
colaboracion_simple.coordinar_tareas() # Coordinar tareas usando la estrategia simple
usuario_decorado = UsuarioDecorator(Usuario())
usuario_decorado = ValidadorUsuario(usuario_decorado)
usuario_decorado.gestionar_cuenta() # Gestionar cuenta con validación de datosClase Proxy para Usuario
class UsuarioProxy:
def __init__(self, usuario_real):
self._usuario_real = usuario_real
def gestionar_cuenta(self):
# Lógica adicional del proxy, si es necesaria
self._usuario_real.gestionar_cuenta()
def autenticar(self):
# Lógica adicional del proxy, si es necesaria
return self._usuario_real.autenticar()
def actualizar_perfil(self):
# Lógica adicional del proxy, si es necesaria
self._usuario_real.actualizar_perfil()
# Implementación concreta de Usuario
class Usuario:
def __init__(self, nombre, correoElectronico, contraseña, tipoUsuario):
self.nombre = nombre
self.correoElectronico = correoElectronico
self.contraseña = contraseña
self.tipoUsuario = tipoUsuario
def gestionar_cuenta(self):
print("Gestionando cuenta de usuario:", self.nombre)
def autenticar(self):
print("Autenticando usuario:", self.nombre)
# Lógica de autenticación aquí
return True
def actualizar_perfil(self):
print("Actualizando perfil de usuario:", self.nombre)
# Uso del patrón Proxy
usuario_real = Usuario("Usuario1", "usuario1@example.com", "contraseña123", "artista")
usuario_proxy = UsuarioProxy(usuario_real)
# El proxy maneja las llamadas a los métodos del usuario real
usuario_proxy.gestionar_cuenta()
usuario_proxy.autenticar()
usuario_proxy.actualizar_perfil()Dado el contexto del proyecto de la Plataforma Web para la Co-creación de Proyectos Artísticos y considerando las funcionalidades descritas, así como la necesidad de un sistema robusto y escalable, te recomendaría utilizar Python como lenguaje de programación principal para el backend y JavaScript para el desarrollo del frontend. Aquí tienes algunas razones para esta recomendación:
Python para el Backend
JavaScript para el Frontend
Una alternativa a Python para el desarrollo del backend podría ser el lenguaje de programación Go (también conocido como Golang).
Una alternativa viable podría ser utilizar TypeScript como alternativa al JavaScript para el frontend.