Scribd
Cargar
3 vistas101 páginas

Database

El documento contiene un conjunto de funciones para gestionar una base de datos SQLite que maneja usuarios y tareas. Incluye funciones para crear y eliminar usuarios, obtener información de usuarios y tareas, y establecer conexiones con la base de datos. También se implementan mecanismos para manejar errores de integridad y operaciones de base de datos.

Cargado por

jaqehlol
Derechos de autor
© All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como TXT, PDF, TXT o lee en línea desde Scribd
3 vistas101 páginas

Database

El documento contiene un conjunto de funciones para gestionar una base de datos SQLite que maneja usuarios y tareas. Incluye funciones para crear y eliminar usuarios, obtener información de usuarios y tareas, y establecer conexiones con la base de datos. También se implementan mecanismos para manejar errores de integridad y operaciones de base de datos.

Cargado por

jaqehlol
Derechos de autor
© All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como TXT, PDF, TXT o lee en línea desde Scribd

import sqlite3

from sqlite3 import IntegrityError, OperationalError, DatabaseError


from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]
except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"
def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()
def eliminar_usuario(usuario_id: int) -> None:
try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))
[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()
[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL
);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()
if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))
row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None
def obtener_todos_los_usuarios() -> list[Usuario]:
try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()
tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in
rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))
[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError
DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []
def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:
try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None
def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))
rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()
def obtener_rol_usuario_db(username: str) -> str | None:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()
if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None
def ver_tareas_usuario(usuario_id: int) -> list[dict]:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")
def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"
def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()
def eliminar_usuario(usuario_id: int) -> None:
try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []
def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:
try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn
def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")
finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()
[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None
def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()
[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")

finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas
import sqlite3
from sqlite3 import IntegrityError, OperationalError, DatabaseError
from clases import Usuario, UsuarioYaExisteError

DB_NAME = "[Link]"

def obtener_conexion():
conn = [Link]("[Link]")
cur = [Link]()
[Link]("PRAGMA foreign_keys = ON;") # 🔥 ACTIVAR FOREIGN KEYS
return conn

def crear_tabla():
try:
with obtener_conexion() as conn:
cur = [Link]()

[Link]("""
CREATE TABLE IF NOT EXISTS usuarios (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT UNIQUE NOT NULL,
rol TEXT DEFAULT 'usuario',
email TEXT,
phone TEXT,
password_hash TEXT NOT NULL,
salt TEXT NOT NULL

);
""")

[Link]("""
CREATE TABLE IF NOT EXISTS tareas (
id INTEGER PRIMARY KEY AUTOINCREMENT,
titulo TEXT NOT NULL,
descripcion TEXT,
usuario_id INTEGER NOT NULL,
FOREIGN KEY (usuario_id) REFERENCES usuarios(id)
);
""")
[Link]()
except (OperationalError, DatabaseError) as e:
print(f"Error al crear las tablas en la base de datos: {e}")

def crear_usuario(username: str, rol: str, email: str, phone: str, password_hash:
str, salt: str) -> int:
try:
conn = obtener_conexion()
cur = [Link]()

[Link]("""
INSERT INTO usuarios (username, rol, email, phone, password_hash, salt)
VALUES (?, ?, ?, ?, ?, ?)
""", (username, rol, email, phone, password_hash, salt))

[Link]()
return [Link]

except IntegrityError:
raise UsuarioYaExisteError("El usuario ya existe en la base de datos.")
finally:
[Link]()

def eliminar_usuario(usuario_id: int) -> None:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("DELETE FROM usuarios WHERE id = ?", (usuario_id,))
[Link]()
[Link]()
except Exception as e:
print(f"Error al eliminar el usuario: {e}")

def obtener_usuario_por_nombre(username: str) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, rol, email, phone, password_hash, salt
FROM usuarios WHERE username = ?
""", (username,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_usuario_por_id(usuario_id: int) -> Usuario | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios WHERE id = ?
""", (usuario_id,))

row = [Link]()
[Link]()

if row:
return Usuario(*row)
return None

def obtener_todos_los_usuarios() -> list[Usuario]:


try:
with obtener_conexion() as conn:
cur = [Link]()
[Link]("""
SELECT id, username, password_hash, salt, rol, email, phone
FROM usuarios
""")
rows = [Link]()
return [Usuario(*row) for row in rows]
except Exception as e:
print(f"Error al obtener usuarios: {e}")
return []

def crear_tarea(titulo: str, descripcion: str, usuario_id: int) -> int:


try:
conn = obtener_conexion()
cur = [Link]()
[Link]("""
INSERT INTO tareas (titulo, descripcion, usuario_id)
VALUES (?, ?, ?)
""", (titulo, descripcion, usuario_id))

[Link]()
return [Link]

except Exception as e:
print(f"Error al crear la tarea: {e}")

finally:
[Link]()

def obtener_rol_usuario_db(username: str) -> str | None:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT rol
FROM usuarios WHERE username = ?
""", (username,))
row = [Link]()
[Link]()
if row:
return row[0]
return None

def ver_tareas_usuario(usuario_id: int) -> list[dict]:


conn = obtener_conexion()
cur = [Link]()

[Link]("""
SELECT id, titulo, descripcion
FROM tareas WHERE usuario_id = ?
""", (usuario_id,))

rows = [Link]()
[Link]()

tareas = [{"id": row[0], "titulo": row[1], "descripcion": row[2]} for row in


rows]
return tareas

También podría gustarte