Function bodies 57 total

export function DashboardApp() {
  return (
    <main className="app-shell">
      <div className="app-shell__content">
        <TaskDashboard />
      </div>
    </main>
  )
}

function App() {
  return <DashboardApp />
}

export function EmptyState({ title, description }: EmptyStateProps) {
  return (
    <div className="empty-state">
      <h3>{title}</h3>
      <p>{description}</p>
    </div>
  )
}

export function StatusBadge({ status }: StatusBadgeProps) {
  const tone = getTaskStatusTone(status)

  return (
    <span className={`status-badge status-badge--${tone}`}>
      <span className="status-badge__dot" />
      {getTaskStatusLabel(status)}
    </span>
  )
}

export function TaskDashboard() {
  const [tasks, setTasks] = useState<Task[]>([])
  const [selectedStatus, setSelectedStatus] = useState<string>('all')
  const [activeTask, setActiveTask] = useState<Task | null>(null)
  const [isLoading, setIsLoading] = useState<boolean>(true)
  const [isSubmitting, setIsSubmitting] = useState<boolean>(false)
  const [busyTaskId, setBusyTaskId] = useState<number | null>(null)
  const [screenError, setScreenError] = useState<string | null>(null)
  const [formError, setFormError] = useState<string | null>(null)

  useEffect(() => {
    void loadTasks(selectedStatus)
  }, [selectedStatus])

  async function loadTasks(statusFilter: string) {
    setIsLoading(true)
    setScreenError(null)

    try {
      const status = statusFilter === 'all' ? undefined : Number(statusFilter)
      const data = await getTasks(status)
      setTasks(data)
    } catch (error) {
      setScreenError(getErrorMessage(error))
    } finally {
      setIsLoading(false)
    }
  }

  async function loadTasks(statusFilter: string) {
    setIsLoading(true)
    setScreenError(null)

    try {
      const status = statusFilter === 'all' ? undefined : Number(statusFilter)
      const data = await getTasks(status)
      setTasks(data)
    } catch (error) {
      setScreenError(getErrorMessage(error))
    } finally {
      setIsLoading(false)
    }
  }

  async function handleSubmit(payload: TaskPayload, taskId?: number): Promise<boolean> {
    setIsSubmitting(true)
    setFormError(null)

    try {
      if (typeof taskId === 'number') {
        const updatePayload: TaskUpdatePayload = { ...payload, id: taskId }
        await updateTask(taskId, updatePayload)
        setActiveTask(null)
      } else {
        await createTask(payload)
      }

      await loadTasks(selectedStatus)
      return true
    } catch (error) {
      setFormError(getErrorMessage(error))
      return false
    } finally {
      setIsSubmitting(false)
    }
  }

  async function handleDelete(task: Task) {
    const confirmed = window.confirm(`¿Eliminar la tarea "${task.name}"?`)
    if (!confirmed) {
      return
    }

    setBusyTaskId(task.id)
    setScreenError(null)

    try {
      await deleteTask(task.id)
      if (activeTask?.id === task.id) {
        setActiveTask(null)
      }
      await loadTasks(selectedStatus)
    } catch (error) {
      setScreenError(getErrorMessage(error))
    } finally {
      setBusyTaskId(null)
    }
  }

function getFilterLabel(value: string): string {
  if (value === '1') {
    return 'Pendiente'
  }

  if (value === '2') {
    return 'Completada'
  }

  return 'Todas'
}

export function TaskForm({
  activeTask,
  isSubmitting,
  formError,
  onCancelEdit,
  onSubmit,
}: TaskFormProps) {
  const [formState, setFormState] = useState<TaskFormState>(INITIAL_STATE)
  const [localError, setLocalError] = useState<string | null>(null)

  useEffect(() => {
    if (!activeTask) {
      setFormState(INITIAL_STATE)
      setLocalError(null)
      return
    }

    setFormState({
      name: activeTask.name,
      beginDate: formatApiDateToInput(activeTask.begin_date),
      endDate: formatApiDateToInput(activeTask.end_date),
      shortDescription: activeTask.short_description ?? '',
      longDescription: activeTask.long_description ?? '',
      status: String(activeTask.status),
    })
    setLocalError(null)
  }, [activeTask])

  async function handleSubmit(event: FormEvent<HTMLFormElement>) {
    event.preventDefault()
    setLocalError(null)

    const beginDate = formatInputDateToApi(formState.beginDate)
    const endDate = formatInputDateToApi(formState.end

  async function handleSubmit(event: FormEvent<HTMLFormElement>) {
    event.preventDefault()
    setLocalError(null)

    const beginDate = formatInputDateToApi(formState.beginDate)
    const endDate = formatInputDateToApi(formState.endDate)

    if (!formState.name.trim()) {
      setLocalError('El nombre de la tarea es obligatorio.')
      return
    }

    if (!isValidApiDate(beginDate) || !isValidApiDate(endDate)) {
      setLocalError('Las fechas deben existir y tener formato DD-MM-YYYY.')
      return
    }

    const payload: TaskPayload = {
      name: formState.name.trim(),
      begin_date: beginDate,
      end_date: endDate,
      short_description: formState.shortDescription.trim() || null,
      long_description: formState.longDescription.trim() || null,
      status: Number(formState.status),
    }

    const wasSuccessful = await onSubmit(payload, activeTask?.id)

    if (!activeTask && wasSuccessful) {
      setFormState(INITIAL_STATE)
    }
  }

  function handleChange<Key extends keyof TaskFormState>(key: Key, value: TaskFormState[Key]) {
    setFormState((current) => ({
      ...current,
      [key]: value,
    }))
  }

export function TaskStatusFilter({ value, disabled = false, onChange }: TaskStatusFilterProps) {
  return (
    <div className="status-filter">
      <label className="status-filter__label" htmlFor="task-status-filter">
        Filtrar por estado
      </label>
      <select
        id="task-status-filter"
        className="select status-filter__select"
        value={value}
        disabled={disabled}
        onChange={(event) => onChange(event.target.value)}
      >
        {TASK_FILTER_OPTIONS.map((option) => (
          <option key={option.value} value={option.value}>
            {option.label}
          </option>
        ))}
      </select>
    </div>
  )
}

export function TaskTable({ tasks, busyTaskId, isLoading, onEdit, onDelete }: TaskTableProps) {
  if (!isLoading && tasks.length === 0) {
    return (
      <div className="table-wrapper">
        <EmptyState
          title="No hay tareas para mostrar"
          description="Crea una nueva tarea o cambia el filtro para ver otros resultados."
        />
      </div>
    )
  }

  return (
    <div className="table-wrapper">
      <div className="table-scroll">
        <table className="task-table">
          <thead>
            <tr>
              <th>Tarea</th>
              <th>Fechas</th>
              <th>Estado</th>
              <th>Descripción larga</th>
              <th>Acciones</th>
            </tr>
          </thead>
          <tbody>
            {tasks.map((task) => {
              const isBusy = busyTaskId === task.id

              return (
                <tr key={task.id}>
                  <td>
                    <p className="task-title">{task.name}</p>
              

export class ApiError extends Error {
  readonly status: number
  readonly detail: unknown

  constructor(message: string, status: number, detail: unknown) {
    super(message)
    this.name = 'ApiError'
    this.status = status
    this.detail = detail
  }
}

  constructor(message: string, status: number, detail: unknown) {
    super(message)
    this.name = 'ApiError'
    this.status = status
    this.detail = detail
  }

export async function requestJson<T>(path: string, options: RequestOptions = {}): Promise<T> {
  const { expectedStatus, headers, ...requestInit } = options
  const response = await fetch(`${API_BASE_URL}${path}`, {
    ...requestInit,
    headers: {
      Accept: 'application/json',
      ...headers,
    },
  })

  const isJsonResponse = response.headers.get('content-type')?.includes('application/json') ?? false
  const responseBody = isJsonResponse ? await response.json() : null

  if (!response.ok) {
    const message =
      extractValidationMessage(responseBody) ||
      (typeof responseBody === 'object' &&
      responseBody !== null &&
      'detail' in responseBody &&
      typeof responseBody.detail === 'string'
        ? responseBody.detail
        : `La solicitud falló con estado ${response.status}.`)

    throw new ApiError(message, response.status, responseBody)
  }

  if (expectedStatus && !expectedStatus.includes(response.status)) {
    throw new ApiError(
      `La API 

function extractValidationMessage(value: unknown): string | null {
  if (!value || typeof value !== 'object' || !('detail' in value)) {
    return null
  }

  const detail = (value as ValidationErrorResponse).detail
  if (!Array.isArray(detail) || detail.length === 0) {
    return null
  }

  return detail.map((issue) => issue.msg).join(' ')
}

export async function getTasks(status?: number): Promise<Task[]> {
  const query = typeof status === 'number' ? `?status=${status}` : ''
  const response = await requestJson<unknown>(`/tasks${query}`, { method: 'GET' })

  if (!Array.isArray(response)) {
    return []
  }

  return response as Task[]
}

export async function createTask(payload: TaskPayload): Promise<CreateTaskResponse> {
  return requestJson<CreateTaskResponse>('/tasks', {
    method: 'POST',
    expectedStatus: [200, 201],
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(payload),
  })
}

export async function updateTask(id: number, payload: TaskUpdatePayload): Promise<void> {
  await requestJson<null>(`/tasks/${id}`, {
    method: 'PUT',
    expectedStatus: [200, 204],
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify(payload),
  })
}

export async function deleteTask(id: number): Promise<void> {
  await requestJson<null>(`/tasks/${id}`, {
    method: 'DELETE',
    expectedStatus: [200, 204],
  })
}

export function isValidApiDate(value: string): boolean {
  const match = API_DATE_REGEX.exec(value)
  if (!match) {
    return false
  }

  const [, day, month, year] = match
  const parsedDate = new Date(Number(year), Number(month) - 1, Number(day))

  return (
    parsedDate.getFullYear() === Number(year) &&
    parsedDate.getMonth() === Number(month) - 1 &&
    parsedDate.getDate() === Number(day)
  )
}

export function formatInputDateToApi(value: string): string {
  if (!value) {
    return ''
  }

  const [year, month, day] = value.split('-')

  return `${day}-${month}-${year}`
}

export function formatApiDateToInput(value: string): string {
  const match = API_DATE_REGEX.exec(value)
  if (!match) {
    return ''
  }

  const [, day, month, year] = match

  return `${year}-${month}-${day}`
}

export function getErrorMessage(error: unknown): string {
  if (error instanceof ApiError) {
    return error.message
  }

  if (error instanceof Error) {
    return error.message
  }

  return 'Ocurrió un error inesperado. Intenta nuevamente.'
}

export function getTaskStatusLabel(status: number): string {
  if (status === 1) {
    return 'Pendiente'
  }

  if (status === 2) {
    return 'Completada'
  }

  return `Estado ${status}`
}

export function getTaskStatusTone(status: number): string {
  if (status === 1) {
    return 'pending'
  }

  if (status === 2) {
    return 'done'
  }

  return 'unknown'
}

class Task(BaseModel):
    name: str
    begin_date: str
    end_date: str
    short_description: str | None
    long_description: str | None
    status: int

class TaskUpdate(BaseModel):
    id: int
    name: str
    begin_date: str
    end_date: str
    short_description: str | None
    long_description: str | None
    status: int

class BaseRepository:
    def __enter__(self):
        # Se ejecuta al momento de abrir la conexión y crea la conexión y el cursor. Retorna el DAO
        self.connection = connect()
        self.cursor = self.connection.cursor()
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        # Se ejecuta siempre al cierre de la operación; en caso de éxito hace commit, sino hace rollback. Para finalizar cierra conexión y cursor.
        if exc_type:
            self.connection.rollback()
        else:
            self.connection.commit()
        self.cursor.close()
        self.connection.close()

    def _execute_query(self, query, params=None, mode=None):
        """
        Ejecuta una consulta SQL.

        # Params:
        - query: la consulta SQL.
        - params: los parámetros para la consulta.
        - mode: 'one' para fetchone, 'all' para fetchall, None para operaciones tipo INSERT/UPDATE/DELETE.
        """
        try:
            if params is None:

    def __enter__(self):
        # Se ejecuta al momento de abrir la conexión y crea la conexión y el cursor. Retorna el DAO
        self.connection = connect()
        self.cursor = self.connection.cursor()
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        # Se ejecuta siempre al cierre de la operación; en caso de éxito hace commit, sino hace rollback. Para finalizar cierra conexión y cursor.
        if exc_type:
            self.connection.rollback()
        else:
            self.connection.commit()
        self.cursor.close()
        self.connection.close()

    def _execute_query(self, query, params=None, mode=None):
        """
        Ejecuta una consulta SQL.

        # Params:
        - query: la consulta SQL.
        - params: los parámetros para la consulta.
        - mode: 'one' para fetchone, 'all' para fetchall, None para operaciones tipo INSERT/UPDATE/DELETE.
        """
        try:
            if params is None:
                self.cursor.execute(query)
            else:
                self.cursor.execute(query, params)

            if mode == "one":
                return fetch_one(self.cursor)
            elif mode == "all":
                return fetch_all(self.cursor)
            elif mode is None:
                return {"rowcount": self.cursor.rowcount, "lastrowid": self.cursor.lastrowid}
        except:
            raise

class TasksRepository(BaseRepository):
    def get_tasks(self):
        query = """SELECT * FROM tasks;"""
        return self._execute_query(query, mode="all")

    def get_task_by_id(self, id: int):
        query = """SELECT * FROM tasks WHERE id = ?;"""
        return self._execute_query(query, params=(id,), mode="one")

    def get_tasks_by_status(self, status: int):
        query = """SELECT * FROM tasks WHERE status = ?"""
        return self._execute_query(query, params=(status,), mode="all")

    def create_task(self, name: str, begin_date: str, end_date: str, short_description: str, long_description: str, status: int):
        query = """
                INSERT INTO tasks (name, begin_date, end_date, short_description, long_description, status)
                VALUES (?, ?, ?, ?, ?, ?);
                """
        try:
            data = self._execute_query(query, mode=None, params=(name, begin_date, end_date, short_description, long_description, status))
            if data["

    def get_tasks(self):
        query = """SELECT * FROM tasks;"""
        return self._execute_query(query, mode="all")

    def get_task_by_id(self, id: int):
        query = """SELECT * FROM tasks WHERE id = ?;"""
        return self._execute_query(query, params=(id,), mode="one")

    def get_tasks_by_status(self, status: int):
        query = """SELECT * FROM tasks WHERE status = ?"""
        return self._execute_query(query, params=(status,), mode="all")

    def create_task(self, name: str, begin_date: str, end_date: str, short_description: str, long_description: str, status: int):
        query = """
                INSERT INTO tasks (name, begin_date, end_date, short_description, long_description, status)
                VALUES (?, ?, ?, ?, ?, ?);
                """
        try:
            data = self._execute_query(query, mode=None, params=(name, begin_date, end_date, short_description, long_description, status))
            if data["rowcount"] == 1:
                return {"id": data["lastrowid"]}
        except Exception:
            raise

    def delete_task(self, id: int):
        query = """DELETE FROM tasks WHERE id = ?;"""
        data = self._execute_query(query, (id,))
        return data

    def update_task(self, id: int, name: str, begin_date: str, end_date: str, short_description: str, long_description: str, status: int):
        query = """
                UPDATE tasks
                SET name = ?, begin_date = ?, end_date = ?,
                short_description = ?, long_description = ?, status = ?
                WHERE id = ?
                """
        return self._execute_query(query, (name, begin_date, end_date, short_description, long_description, status, id))

async def get_tasks(status: int | None = None):
    with TasksRepository() as repo:
        service = TasksService(repo)
        data = None
        if status is not None:
            try:
                data = service.list_tasks_by_status(status)
            except ValueError as e:
                raise HTTPException(400, detail=f"{e}")
        else:
            data = service.list_tasks()
        return data

async def create_task(task: Task):
    with TasksRepository() as repo:
        service = TasksService(repo)
        try:
            task = service.create_task_service(
                                    task.name,
                                    task.begin_date,
                                    task.end_date,
                                    task.short_description,
                                    task.long_description,
                                    task.status
                                    )
            return JSONResponse(content={"id": task}, status_code=201, headers={"Location": f"/tasks/{task}"})
        except ValueError as e:
            raise HTTPException(400, detail=str(e))
        except Exception as e:
            raise HTTPException(500, detail=str(e))

async def delete_task(id: int):
    with TasksRepository() as repo:
        service = TasksService(repo)

        try:
            task = service.get_task(id)
        except NotFoundError:
            raise HTTPException(status_code=404, detail=f"No existe la tarea con ID: {id}")

        service.delete_task_service(task["id"])
        return Response(status_code=204)

async def update_task(task: TaskUpdate):
    try:
        with TasksRepository() as repo:
            service = TasksService(repo)
            service.update_task_service(
                task.id,
                task.name,
                task.begin_date,
                task.end_date,
                task.short_description,
                task.long_description,
                task.status
            )
            return Response(status_code=204)
    except ValueError as e:
        raise HTTPException(400, detail=str(e))
    except NotFoundError as e:
        raise HTTPException(404, detail=str(e))

class TasksService:
    def __init__(self, repo: TasksRepository):
        self.repo = repo

    def list_tasks(self):
        return self.repo.get_tasks()

    def get_task(self, id: int):
        task = self.repo.get_task_by_id(id)
        if not task:
            raise NotFoundError("La tarea no existe.")
        return task

    def list_tasks_by_status(self, status: int):
        if status not in (0, 1, 2):
            raise ValueError("Estado inválido.")
        return self.repo.get_tasks_by_status(status)

    def create_task_service(self, name: str, begin_date: str, end_date: str, short_description: str, long_description: str, status: int):
        if not name:
            raise ValueError("La tarea debe tener un nombre")

        if not validate_date(begin_date):
            raise ValueError("La fecha de inicio no es válida.")

        if not validate_date(end_date):
            raise ValueError("La fecha de finalización no es válida.")

        if status not in (0, 1, 2):
   

    def get_task(self, id: int):
        task = self.repo.get_task_by_id(id)
        if not task:
            raise NotFoundError("La tarea no existe.")
        return task

    def list_tasks_by_status(self, status: int):
        if status not in (0, 1, 2):
            raise ValueError("Estado inválido.")
        return self.repo.get_tasks_by_status(status)

    def create_task_service(self, name: str, begin_date: str, end_date: str, short_description: str, long_description: str, status: int):
        if not name:
            raise ValueError("La tarea debe tener un nombre")

        if not validate_date(begin_date):
            raise ValueError("La fecha de inicio no es válida.")

        if not validate_date(end_date):
            raise ValueError("La fecha de finalización no es válida.")

        if status not in (0, 1, 2):
            raise ValueError("Estado inválido.")

        try:
            data = self.repo.create_task(name, begin_date, end_date, short_description, long_description, status)
            lastrowid = data.get("id")
            if lastrowid:
                return lastrowid
        except Exception:
            raise

    def delete_task_service(self, id: int):
        try:
            data = self.repo.delete_task(id)
            rowcount = data["rowcount"]
            if rowcount == 0:
                raise NotFoundError("La tarea no existe en la base de datos.")
            return True
        except Exception:
            raise