E1: Modelado del Dominio

¿Qué es el Proyecto Incremental?

TaskFlow es un sistema de gestión de tareas que construirás durante todo el semestre. Esta entrega (E1) es la base. Todo lo que construyas aquí lo usarás en E2, E3, E4, E5 y E6. Es fundamental que quede bien.

Clases Relacionadas

Estas clases preparan los conocimientos necesarios para esta evaluación:

Clase 01: Clases y Objetos Conceptos básicos de POO
Clase 02: Encapsulamiento @property, validaciones

Clase 03: Herencia y Polimorfismo Jerarquías de clases
Clase 04: Clases Abstractas ABC, interfaces

Objetivo de Aprendizaje

Implementar la capa de dominio del sistema TaskFlow utilizando Programación Orientada a Objetos avanzada en Python. Aplicar encapsulamiento, herencia, polimorfismo y clases abstractas.

Modalidad de Trabajo

Individual o en parejas (máximo 2 personas).

Formato de entrega: Repositorio GitHub con código fuente + README.md con instrucciones de ejecución. El repositorio debe ser privado y compartir acceso al docente.

Requisitos Técnicos Detallados

1. Clase Usuario

Descripción: Representa un usuario del sistema TaskFlow que puede crear proyectos y tareas.

Atributos obligatorios:

username (str, inmutable): Identificador único, mínimo 3 caracteres, solo letras y números
email (str): Correo electrónico validado (debe contener @ y .)
nombre_completo (str, opcional): Nombre real del usuario
activo (bool): Estado de la cuenta, por defecto True
fecha_registro (datetime): Se asigna automáticamente al crear

Métodos obligatorios:

activar() -> None: Activa la cuenta del usuario
desactivar() -> None: Desactiva la cuenta
__str__() -> str: Retorna @username
__repr__() -> str: Retorna Usuario('username', 'email')

Validaciones requeridas:

Username: mínimo 3 caracteres, solo alfanuméricos
Email: debe contener @ y punto (validación en setter con @property)
Lanzar ValueError con mensaje descriptivo si falla

2. Clase Proyecto

Descripción: Un proyecto agrupa múltiples tareas y tiene un líder (Usuario).

Atributos obligatorios:

nombre (str): Nombre del proyecto, mínimo 3 caracteres
descripcion (str, opcional): Descripción del proyecto
lider (Usuario): Referencia al usuario líder del proyecto
tareas (list[Tarea]): Lista de tareas, inicia vacía (composición)
fecha_creacion (datetime): Se asigna automáticamente

Métodos obligatorios:

agregar_tarea(tarea: Tarea) -> None: Agrega una tarea al proyecto
obtener_tareas_pendientes() -> list[Tarea]: Retorna tareas no completadas
obtener_tareas_por_prioridad(prioridad: PrioridadTarea) -> list[Tarea]
__str__() -> str: Retorna el nombre del proyecto

Relación de composición: El proyecto "posee" las tareas. Si se elimina el proyecto, sus tareas también deberían eliminarse conceptualmente.

3. Clase Tarea

Descripción: Una tarea individual dentro de un proyecto con estado y prioridad.

Atributos obligatorios:

titulo (str): Título de la tarea, mínimo 3 caracteres
descripcion (str, opcional): Detalles de la tarea
prioridad (PrioridadTarea): Enum con valores ALTA, MEDIA, BAJA
estado (EstadoTarea): Enum con valores PENDIENTE, EN_PROGRESO, COMPLETADA
fecha_creacion (datetime): Se asigna automáticamente
fecha_completado (datetime, opcional): Se asigna al completar

Métodos obligatorios:

completar() -> None: Marca la tarea como completada y registra fecha
cambiar_prioridad(nueva_prioridad: PrioridadTarea) -> None
iniciar() -> None: Cambia estado a EN_PROGRESO
__str__() -> str: Retorna [PRIORIDAD] titulo (estado)

4. Enums (enums.py)

Descripción: Definir enumeraciones para tipos seguros usando enum.Enum.

PrioridadTarea:

ALTA = 1
MEDIA = 2
BAJA = 3

EstadoTarea:

PENDIENTE = "pendiente"
EN_PROGRESO = "en_progreso"
COMPLETADA = "completada"

5. Calidad de Código

Estándares obligatorios:

PEP 8: Código formateado según estándares Python (usar black o autopep8)
Type Hints: Todos los parámetros y retornos deben estar tipados
Docstrings: Formato Google en todas las clases y métodos públicos
Validaciones: ValueError con mensajes claros y descriptivos
Encapsulamiento: Atributos privados con _, acceso vía @property

Ejemplo de docstring formato Google:

def agregar_tarea(self, tarea: Tarea) -> None:
    """Agrega una tarea al proyecto.

    Args:
        tarea: La tarea a agregar. No puede ser None.

    Raises:
        ValueError: Si la tarea es None o ya existe en el proyecto.
    """

Ejemplo de Implementación

src/domain/usuario.py

from datetime import datetime
from typing import Optional


class Usuario:
    """Representa un usuario en el sistema TaskFlow.

    Attributes:
        username: Identificador único del usuario (inmutable).
        email: Correo electrónico validado.
        nombre_completo: Nombre completo del usuario (opcional).
        activo: Estado de la cuenta.
        fecha_registro: Fecha de creación de la cuenta.
    """

    def __init__(
        self,
        username: str,
        email: str,
        nombre_completo: Optional[str] = None
    ) -> None:
        """Inicializa un nuevo usuario.

        Args:
            username: Identificador único (mínimo 3 caracteres, alfanumérico).
            email: Correo electrónico válido.
            nombre_completo: Nombre completo opcional.

        Raises:
            ValueError: Si el username tiene menos de 3 caracteres.
            ValueError: Si el email no tiene formato válido.
        """
        if len(username) < 3:
            raise ValueError("Username debe tener al menos 3 caracteres")
        if not username.isalnum():
            raise ValueError("Username solo puede contener letras y números")

        self._username = username  # Atributo privado (inmutable)
        self._email = None
        self.email = email  # Usa el setter para validar
        self.nombre_completo = nombre_completo
        self.activo = True
        self.fecha_registro = datetime.now()

    @property
    def username(self) -> str:
        """Username inmutable del usuario."""
        return self._username

    @property
    def email(self) -> str:
        """Email del usuario."""
        return self._email

    @email.setter
    def email(self, valor: str) -> None:
        """Valida y asigna el email.

        Args:
            valor: Email a validar.

        Raises:
            ValueError: Si el email no contiene @ o punto.
        """
        if "@" not in valor or "." not in valor:
            raise ValueError(f"Email inválido: {valor}")
        self._email = valor

    def activar(self) -> None:
        """Activa la cuenta del usuario."""
        self.activo = True

    def desactivar(self) -> None:
        """Desactiva la cuenta del usuario."""
        self.activo = False

    def __str__(self) -> str:
        return f"@{self.username}"

    def __repr__(self) -> str:
        return f"Usuario('{self.username}', '{self.email}')"

Estructura de Entrega

Organización de Archivos Obligatoria

src/ ├── __init__.py └── domain/ ├── __init__.py ├── enums.py # PrioridadTarea, EstadoTarea ├── usuario.py # Clase Usuario ├── proyecto.py # Clase Proyecto └── tarea.py # Clase Tarea README.md # Instrucciones para ejecutar el proyecto test_dominio.py # Tests básicos (opcional pero recomendado) requirements.txt # Dependencias (si las hay)

Pasos para Completar la Evaluación

1Crear la estructura de carpetas

Crear src/domain/ con los archivos __init__.py

2Implementar los Enums

Crear PrioridadTarea y EstadoTarea en enums.py

3Implementar la clase Usuario

Con validaciones, properties y type hints

4Implementar la clase Tarea

Usando los enums para prioridad y estado

5Implementar la clase Proyecto

Con la relación de composición con Tarea

6Crear tests básicos

Verificar que todo funcione correctamente

7Documentar en README.md

Cómo ejecutar el código y ejemplos de uso

Rúbrica de Evaluación (100%)

Criterio	Excelente (5.0)	Aceptable (3.5)	Insuficiente	Peso
Funcionalidad	Todas las clases funcionan correctamente, validaciones robustas, manejo de errores completo	Funciona pero validaciones básicas, algunos edge cases sin manejar	No funciona o faltan clases principales	30%
Arquitectura POO	Excelente encapsulamiento, properties bien usadas, herencia aplicada donde corresponde	Uso básico de clases, algunos atributos públicos sin razón	No aplica POO, todo procedural o atributos públicos	25%
Type Hints	100% del código tipado correctamente, incluyendo Optional, Union donde corresponde	Mayoría tipado, algunos métodos sin tipar	Sin type hints o solo algunos	20%
Documentación	Docstrings Google style completos en todas las clases y métodos públicos	Algunos docstrings presentes, formato inconsistente	Sin documentación o solo comentarios	15%
Tests (bonus)	Tests exhaustivos con pytest, cubren edge cases y validaciones	Tests básicos funcionales, cobertura parcial	Sin tests	10%

Penalizaciones

Código sin type hints: Nota máxima 3.5
Sin validaciones: Nota máxima 3.0
Atributos públicos sin razón: -0.5 por cada uno
Sin docstrings: -1.0 punto
README vacío o sin instrucciones: -0.5 puntos
Código que no ejecuta: Nota máxima 2.0

Conexión con E2

El dominio que construyas aquí será la base para E2: Testing y Calidad. Asegúrate de que funcione correctamente porque lo testearás en la siguiente entrega.

← Inicio E2: Testing →