Corrección de tablas y mejora en la documentación e implementación de Singleton

Dockerfile

@@ -9,7 +9,6 @@ RUN pip install --no-cache-dir -r /code/requirements.txt
 
 COPY . .
 
-# Cambia los permisos del directorio
 RUN chmod -R 777 /code
 
 # Comando para ejecutar la aplicación

main.py

@@ -6,424 +6,364 @@ app = FastAPI()
 # uvicorn main:app --host localhost --port 7860 --reload
 
 
-def get_db_connection():
+class DatabaseConnection:
     """
-    Establece una conexión a la base de datos optica.db y configura el objeto de conexión para devolver filas como objetos Row de SQLite.
-
-    Devuelve las filas como objetos Row de SQLite (para poder acceder a los campos por nombre) sin eso el formato es lista de tuplas y no se puede acceder a los campos por nombre de columna (solo por indice)
-
-    Returns:
-        conn (sqlite3.Connection): Objeto de conexión a la base de datos.
+    Clase Singleton para gestionar las conexiones a la base de datos.
     """
-    conn = sqlite3.connect("optica.db")
-    conn.row_factory = sqlite3.Row
-    return conn
 
+    _instance = None
 
-######################
-# CREATE TABLE usuario (
-#     Id INTEGER PRIMARY KEY AUTOINCREMENT,
-#     Nombre_usuario VARCHAR,
-#     Clave VARCHAR,
-#     Pregunta_recuperacion VARCHAR,
-#     Respuesta VARCHAR,
-#     Estado VARCHAR
-# )
-######################
-# metodos get, post, put, delete para la tabla usuario deben retornar un json
+    def __new__(cls):
+        """
+        Crea una nueva instancia de la clase si no existe.
+        """
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance.conn = sqlite3.connect("optica.db")
+            cls._instance.conn.row_factory = sqlite3.Row
+        return cls._instance
+
+    def get_connection(self):
+        """
+        Obtener el objeto de conexión de la base de datos.
+        """
+        return self.conn
 
 
-# pagina de inicio
+# saludo
 @app.get("/")
-def home():
-    """
-    Página de inicio de la API.
+def read_root():
+    """Saludo de la API
 
     Returns:
-        dict: Un diccionario con un mensaje de bienvenida.
+        string: Un mensaje de saludo.
     """
-    return {"message": "Bienvenido a la API de la óptica"}
+    return {"message": "Saludos desde la API de Optica 2023"}
 
 
-# GET /usuario
-# Obtener todos los usuarios
+# GET /usuarios
 @app.get("/usuarios")
 def get_usuarios():
     """
-    Obtiene una lista de usuarios desde la base de datos.
+    Obtiene todos los usuarios de la base de datos.
 
     Returns:
-        list[dict]: Una lista de diccionarios que representan los usuarios.
+        list: Una lista con todos los usuarios.
     """
-    conn = get_db_connection()
+    conn = DatabaseConnection().get_connection()
     cursor = conn.cursor()
     cursor.execute("SELECT * FROM usuario")
     usuarios = cursor.fetchall()
-    conn.close()
     return usuarios
 
 
-# Obtener un usuario por ID
-@app.get("/usuarios/{usuario_id}")
-def get_usuario(usuario_id: int):
+@app.get("/usuarios/{id}")
+def get_usuario(id: int):
     """
-    Obtiene un usuario de la base de datos según su ID.
+    Obtiene un usuario por su ID.
 
     Parámetros:
-    - usuario_id (int): El ID del usuario a obtener.
+    - id (int): El ID del usuario a obtener.
 
     Retorna:
     - dict: Un diccionario con la información del usuario.
 
     Lanza:
-    - HTTPException: Si el usuario no se encuentra en la base de datos.
+    - HTTPException: Si no se encuentra el usuario con el ID especificado.
     """
-    conn = get_db_connection()
+    conn = DatabaseConnection().get_connection()
     cursor = conn.cursor()
-    cursor.execute("SELECT * FROM usuario WHERE Id = ?", (usuario_id,))
+    cursor.execute("SELECT * FROM usuario WHERE Id = ?", (id,))
     usuario = cursor.fetchone()
-    conn.close()
     if usuario:
         return usuario
-    else:
-        raise HTTPException(status_code=404, detail="Usuario no encontrado")
+    raise HTTPException(status_code=404, detail="Usuario no encontrado")
 
 
-# POST /usuario
-# se necesita crear una clase que represente el modelo de usuario en la tabla usuario
-class UsuarioCreate(BaseModel):
-    """
-    Clase que representa el modelo de un usuario al momento de crearlo.
-    """
-
+# crear clase usuario
+class Usuario(BaseModel):
     Nombre_usuario: str
     Clave: str
     Pregunta_recuperacion: str
     Respuesta: str
-    Estado: str
-
-
-## Crear un nuevo usuario
-# @app.post("/usuarios/", response_model=dict)
-# def create_usuario(usuario: UsuarioCreate = Body(...)):
-#    """
-#    Crea un nuevo usuario en la base de datos.
-#
-#    Args:
-#        usuario (UsuarioCreate): Los datos del usuario a crear.
-#
-#    Returns:
-#        dict: Un diccionario que contiene el ID del nuevo usuario y los datos del usuario creado.
-#    """
-#    conn = get_db_connection()
-#    cursor = conn.cursor()
-#
-#    # Insertar nuevo usuario en la base de datos
-#    cursor.execute(
-#        """
-#        INSERT INTO usuario (Nombre_usuario, Clave, Pregunta_recuperacion, Respuesta, Estado)
-#        VALUES (?, ?, ?, ?, ?)
-#    """,
-#        (
-#            usuario.Nombre_usuario,
-#            usuario.Clave,
-#            usuario.Pregunta_recuperacion,
-#            usuario.Respuesta,
-#            usuario.Estado,
-#        ),
-#    )
-#    # Obtener el ID del nuevo usuario
-#    nuevo_usuario_id = cursor.lastrowid
-#    # Confirmar los cambios y cerrar la conexión
-#    conn.commit()
-#    conn.close()
-#    # Devolver el nuevo usuario creado
-#    return {"Id": nuevo_usuario_id, **usuario.dict()}
-#
-
-
-# PUT /usuario
-@app.put("/usuarios/{usuario_id}")
-def update_usuario(usuario_id: int, usuario: UsuarioCreate = Body(...)):
+    estado: str
+
+
+@app.post("/usuarios")
+def create_usuario(usuario: Usuario):
+    """
+    Crea un nuevo usuario en la base de datos.
+
+    Args:
+        usuario (Usuario): El objeto Usuario que contiene los datos del usuario a crear.
+
+    Returns:
+        dict: Un diccionario con el ID del usuario recién creado y los datos del usuario.
+    """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+    cursor.execute(
+        """
+        INSERT INTO usuario (Nombre_usuario, Clave, Pregunta_recuperacion, Respuesta, estado)
+        VALUES (?, ?, ?, ?, ?)
+        """,
+        (
+            usuario.Nombre_usuario,
+            usuario.Clave,
+            usuario.Pregunta_recuperacion,
+            usuario.Respuesta,
+            usuario.estado,
+        ),
+    )
+    conn.commit()
+    return {"id": cursor.lastrowid, **usuario.dict()}
+
+
+@app.put("/usuarios/{id}")
+def update_usuario(id: int, usuario: Usuario):
     """
     Actualiza un usuario en la base de datos.
 
     Parámetros:
-    - usuario_id (int): El ID del usuario a actualizar.
-    - usuario (UsuarioCreate): Los datos del usuario a actualizar.
+    - id (int): El ID del usuario a actualizar.
+    - usuario (Usuario): Objeto Usuario con los datos actualizados.
 
     Retorna:
-    - dict: Un diccionario que contiene el ID del usuario actualizado y los datos del usuario actualizado.
+    - dict: Un diccionario con el mensaje de éxito de la actualización.
 
     Lanza:
-    - HTTPException: Si el usuario no se encuentra en la base de datos.
+    - HTTPException: Si no se encuentra el usuario en la base de datos.
     """
-    conn = get_db_connection()
+    conn = DatabaseConnection().get_connection()
     cursor = conn.cursor()
-
-    # Actualizar usuario en la base de datos
     cursor.execute(
         """
         UPDATE usuario
-        SET Nombre_usuario = ?, Clave = ?, Pregunta_recuperacion = ?, Respuesta = ?, Estado = ?
+        SET Nombre_usuario = ?,
+            Clave = ?,
+            Pregunta_recuperacion = ?,
+            Respuesta = ?,
+            estado = ?
         WHERE Id = ?
-    """,
+        """,
         (
             usuario.Nombre_usuario,
             usuario.Clave,
             usuario.Pregunta_recuperacion,
             usuario.Respuesta,
-            usuario.Estado,
-            usuario_id,
+            usuario.estado,
+            id,
         ),
     )
-    # Confirmar los cambios y cerrar la conexión
     conn.commit()
-    conn.close()
-    # Devolver el usuario actualizado
-    return {"Id": usuario_id, **usuario.dict()}
+    if cursor.rowcount < 1:
+        raise HTTPException(status_code=404, detail="Usuario no encontrado")
+    return {"message": "Usuario actualizado"}
+
+
+@app.delete("/usuarios/{id}")
+def delete_usuario(id: int):
+    """
+    Elimina un usuario de la base de datos.
 
+    Args:
+        id (int): El ID del usuario a eliminar.
+
+    Returns:
+        dict: Un diccionario con el mensaje de éxito de eliminación.
 
-# CREATE TABLE cliente (
-#         Id INTEGER PRIMARY KEY AUTOINCREMENT,
-#         Nombres_completos VARCHAR,
-#         Telefono VARCHAR,
-#         Edad INTEGER,
-#         Direccion VARCHAR,
-#         fecha_registro VARCHAR,
-#         Nota_adicional VARCHAR
-#     )
+    Raises:
+        HTTPException: Si no se encuentra el usuario con el ID especificado.
+    """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+    cursor.execute("DELETE FROM usuario WHERE Id = ?", (id,))
+    conn.commit()
+    if cursor.rowcount < 1:
+        raise HTTPException(status_code=404, detail="Usuario no encontrado")
+    return {"message": "Usuario eliminado"}
 
 
-# GET /cliente
-# Obtener todos los clientes
 @app.get("/clientes")
 def get_clientes():
     """
-    Obtiene una lista de clientes desde la base de datos.
+    Obtiene todos los clientes de la base de datos.
 
     Returns:
-        list[dict]: Una lista de diccionarios que representan los clientes.
+        list: Lista de todos los clientes.
     """
-    conn = get_db_connection()
+    conn = DatabaseConnection().get_connection()
     cursor = conn.cursor()
     cursor.execute("SELECT * FROM cliente")
     clientes = cursor.fetchall()
-    conn.close()
     return clientes
 
 
-# Obtener un cliente por nombres completos (convertidos a minúsculas)
-@app.get("/clientes/{nombres_completos}")
-def buscar_cliente(nombres_completos: str):
+@app.get("/clientes/{id}")
+def get_cliente(id: int):
     """
-    Obtiene un cliente de la base de datos según su nombre completo.
+    Obtiene un cliente por su ID.
 
     Parámetros:
-    - nombres_completos (str): El nombre completo del cliente a obtener.
+    - id: int, el ID del cliente a buscar.
 
     Retorna:
-    - dict: Un diccionario con la información del cliente.
+    - dict: Los datos del cliente encontrado.
 
     Lanza:
-    - HTTPException: Si el cliente no se encuentra en la base de datos.
+    - HTTPException: Si no se encuentra ningún cliente con el ID especificado.
     """
-    nombres_completos_lower = (
-        nombres_completos.lower()
-    )  # Convertir a minúsculas para la búsqueda
-    conn = get_db_connection()
+    conn = DatabaseConnection().get_connection()
     cursor = conn.cursor()
-    cursor.execute(
-        "SELECT * FROM cliente WHERE LOWER(Nombres_completos) = ?",
-        (nombres_completos_lower,),
-    )
+    cursor.execute("SELECT * FROM cliente WHERE Id = ?", (id,))
     cliente = cursor.fetchone()
-    conn.close()
     if cliente:
         return cliente
-    else:
-        raise HTTPException(status_code=404, detail="Cliente no encontrado")
+    raise HTTPException(status_code=404, detail="Cliente no encontrado")
 
 
-# POST /cliente
-# se necesita crear una clase que represente el modelo de cliente en la tabla cliente
-class ClienteCreate(BaseModel):
-    """
-    Clase que representa el modelo de un cliente al momento de crearlo.
-    """
-
+class Cliente(BaseModel):
     Nombres_completos: str
     Telefono: str
     Edad: int
     Direccion: str
     fecha_registro: str
-    Nota_adicional: str
 
 
-# Crear un nuevo cliente
-@app.post("/clientes/")
-def create_cliente(cliente: ClienteCreate = Body(...)):
+@app.post("/clientes")
+def create_cliente(cliente: Cliente):
     """
     Crea un nuevo cliente en la base de datos.
 
     Args:
-        cliente (ClienteCreate): Los datos del cliente a crear.
+        cliente (Cliente): Objeto Cliente con los datos del cliente a crear.
 
     Returns:
-        dict: Un diccionario que contiene el ID del nuevo cliente y los datos del cliente creado.
+        dict: Un diccionario con el ID del cliente recién creado y los datos del cliente.
     """
-    conn = get_db_connection()
+    conn = DatabaseConnection().get_connection()
     cursor = conn.cursor()
-
-    # Insertar nuevo cliente en la base de datos
     cursor.execute(
         """
-        INSERT INTO cliente (Nombres_completos, Telefono, Edad, Direccion, fecha_registro, Nota_adicional)
-        VALUES (?, ?, ?, ?, ?, ?)
-    """,
+        INSERT INTO cliente (Nombres_completos, Telefono, Edad, Direccion, fecha_registro)
+        VALUES (?, ?, ?, ?, ?)
+        """,
         (
             cliente.Nombres_completos,
             cliente.Telefono,
             cliente.Edad,
             cliente.Direccion,
             cliente.fecha_registro,
-            cliente.Nota_adicional,
         ),
     )
-    # Obtener el ID del nuevo cliente
-    nuevo_cliente_id = cursor.lastrowid
-    # Confirmar los cambios y cerrar la conexión
     conn.commit()
-    conn.close()
-    # Devolver el nuevo cliente creado
-    return {"Id": nuevo_cliente_id, **cliente.dict()}
+    return {"id": cursor.lastrowid, **cliente.dict()}
 
 
-# PUT /cliente
-@app.put("/clientes/{cliente_id}")
-def update_cliente(cliente_id: int, cliente: ClienteCreate = Body(...)):
+@app.put("/clientes/{id}")
+def update_cliente(id: int, cliente: Cliente):
     """
-    Actualiza un cliente en la base de datos.
+    Actualiza los datos de un cliente en la base de datos.
 
     Parámetros:
-    - cliente_id (int): El ID del cliente a actualizar.
-    - cliente (ClienteCreate): Los datos del cliente a actualizar.
+    - id (int): El ID del cliente a actualizar.
+    - cliente (Cliente): Objeto Cliente con los nuevos datos del cliente.
 
     Retorna:
-    - dict: Un diccionario que contiene el ID del cliente actualizado y los datos del cliente actualizado.
+    - dict: Un diccionario con el mensaje de éxito de la actualización.
 
-    Lanza:
-    - HTTPException: Si el cliente no se encuentra en la base de datos.
+    Excepciones:
+    - HTTPException: Si no se encuentra el cliente con el ID especificado.
     """
-    conn = get_db_connection()
+    conn = DatabaseConnection().get_connection()
     cursor = conn.cursor()
-
-    # Actualizar cliente en la base de datos
     cursor.execute(
         """
         UPDATE cliente
-        SET Nombres_completos = ?, Telefono = ?, Edad = ?, Direccion = ?, fecha_registro = ?, Nota_adicional = ?
+        SET Nombres_completos = ?,
+            Telefono = ?,
+            Edad = ?,
+            Direccion = ?,
+            fecha_registro = ?
         WHERE Id = ?
-    """,
+        """,
         (
             cliente.Nombres_completos,
             cliente.Telefono,
             cliente.Edad,
             cliente.Direccion,
             cliente.fecha_registro,
-            cliente.Nota_adicional,
-            cliente_id,
+            id,
         ),
     )
-    # Confirmar los cambios y cerrar la conexión
     conn.commit()
-    conn.close()
-    # Devolver el cliente actualizado
-    return {"Id": cliente_id, **cliente.dict()}
+    if cursor.rowcount < 1:
+        raise HTTPException(status_code=404, detail="Cliente no encontrado")
+    return {"message": "Cliente actualizado"}
 
 
-# DELETE /cliente
-@app.delete("/clientes/{cliente_id}")
-def delete_cliente(cliente_id: int):
+@app.delete("/clientes/{id}")
+def delete_cliente(id: int):
     """
     Elimina un cliente de la base de datos.
 
     Parámetros:
-    - cliente_id (int): El ID del cliente a eliminar.
+    - id: int, el ID del cliente a eliminar.
 
     Retorna:
-    - dict: Un diccionario que contiene el ID del cliente eliminado.
+    - dict: Un diccionario con el mensaje de éxito de eliminación.
 
     Lanza:
-    - HTTPException: Si el cliente no se encuentra en la base de datos.
+    - HTTPException: Si no se encuentra el cliente con el ID especificado.
     """
-    conn = get_db_connection()
+    conn = DatabaseConnection().get_connection()
     cursor = conn.cursor()
-
-    # Eliminar cliente de la base de datos
-    cursor.execute("DELETE FROM cliente WHERE Id = ?", (cliente_id,))
-    # Confirmar los cambios y cerrar la conexión
+    cursor.execute("DELETE FROM cliente WHERE Id = ?", (id,))
     conn.commit()
-    conn.close()
-    # Devolver el cliente eliminado
-    return {"Id": cliente_id}
-
-    # CREATE TABLE detalles_opticos (
-    #     Id INTEGER PRIMARY KEY AUTOINCREMENT,
-    #     Esfera_OD_lejos VARCHAR,
-    #     Cilindro_OD_lejos VARCHAR,
-    #     Eje_OD_lejos VARCHAR,
-    #     Agudeza_visual_OD_lejos VARCHAR,
-    #     Esfera_OI_lejos VARCHAR,
-    #     Cilindro_OI_lejos VARCHAR,
-    #     Eje_OI_lejos VARCHAR,
-    #     Agudeza_visual_OI_lejos VARCHAR,
-    #     Esfera_OD_cerca VARCHAR,
-    #     Cilindro_OD_cerca VARCHAR,
-    #     Eje_OD_cerca VARCHAR,
-    #     Agudeza_visual_OD_cerca VARCHAR,
-    #     Esfera_OI_cerca VARCHAR,
-    #     Cilindro_OI_cerca VARCHAR,
-    #     Eje_OI_cerca VARCHAR,
-    #     Agudeza_visual_OI_cerca VARCHAR,
-    #     Id_cliente INTEGER REFERENCES cliente(Id)
-    # )
-
-
-# GET /detalles_opticos
-# Obtener detalles opticos de un cliente por ID
-@app.get("/detalles_opticos/{cliente_id}")
-def get_detalles_opticos(cliente_id: int):
-    """
-    Obtiene los detalles ópticos de un cliente de la base de datos según su ID.
+    if cursor.rowcount < 1:
+        raise HTTPException(status_code=404, detail="Cliente no encontrado")
+    return {"message": "Cliente eliminado"}
 
-    Parámetros:
-    - cliente_id (int): El ID del cliente del cual se obtendrán los detalles ópticos.
 
-    Retorna:
-    - dict: Un diccionario con la información de los detalles ópticos del cliente.
+@app.get("/medidas")
+def get_medidas():
+    """
+    Obtiene todas las medidas de la base de datos.
 
-    Lanza:
-    - HTTPException: Si el cliente no se encuentra en la base de datos.
+    Returns:
+        list: Lista de todas las medidas.
     """
-    conn = get_db_connection()
+    conn = DatabaseConnection().get_connection()
     cursor = conn.cursor()
-    cursor.execute("SELECT * FROM detalles_opticos WHERE Id_cliente = ?", (cliente_id,))
-    detalles_opticos = cursor.fetchone()
-    conn.close()
-    if detalles_opticos:
-        return detalles_opticos
-    else:
-        raise HTTPException(status_code=404, detail="Detalles ópticos no encontrados")
+    cursor.execute("SELECT * FROM medidas")
+    medidas = cursor.fetchall()
+    return medidas
 
 
-# POST /detalles_opticos
-# se necesita crear una clase que represente el modelo de detalles_opticos en la tabla detalles_opticos
-class DetallesOpticosCreate(BaseModel):
+@app.get("/medidas/{id}")
+def get_medida(id: int):
     """
-    Clase que representa el modelo de detalles ópticos al momento de crearlos.
+    Obtiene una medida por su ID.
+
+    Parámetros:
+    - id: int, el ID de la medida a obtener.
+
+    Retorna:
+    - dict: La medida encontrada.
+
+    Lanza:
+    - HTTPException: Si la medida no es encontrada.
     """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM medidas WHERE Id = ?", (id,))
+    medida = cursor.fetchone()
+    if medida:
+        return medida
+    raise HTTPException(status_code=404, detail="Medida no encontrada")
 
+
+class Medida(BaseModel):
     Esfera_OD_lejos: str
     Cilindro_OD_lejos: str
     Eje_OD_lejos: str
@@ -440,160 +380,398 @@ class DetallesOpticosCreate(BaseModel):
     Cilindro_OI_cerca: str
     Eje_OI_cerca: str
     Agudeza_visual_OI_cerca: str
-    Id_cliente: int
 
 
-# Ruta para crear detalles ópticos para un cliente
-@app.post("/clientes/{cliente_id}/detalles_opticos")
-def create_detalles_opticos(
-    cliente_id: int, detalles_opticos: DetallesOpticosCreate = Body(...)
-):
+@app.post("/medidas")
+def create_medida(medida: Medida):
+    """
+    Crea una nueva medida en la base de datos.
+
+    Args:
+        medida (Medida): Objeto que contiene los datos de la medida a crear.
+
+    Returns:
+        dict: Un diccionario que contiene el ID de la medida creada y los datos de la medida.
+    """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+    cursor.execute(
+        """
+        INSERT INTO medidas (Esfera_OD_lejos, Cilindro_OD_lejos, Eje_OD_lejos, Agudeza_visual_OD_lejos, Esfera_OI_lejos, Cilindro_OI_lejos, Eje_OI_lejos, Agudeza_visual_OI_lejos, Esfera_OD_cerca, Cilindro_OD_cerca, Eje_OD_cerca, Agudeza_visual_OD_cerca, Esfera_OI_cerca, Cilindro_OI_cerca, Eje_OI_cerca, Agudeza_visual_OI_cerca)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            medida.Esfera_OD_lejos,
+            medida.Cilindro_OD_lejos,
+            medida.Eje_OD_lejos,
+            medida.Agudeza_visual_OD_lejos,
+            medida.Esfera_OI_lejos,
+            medida.Cilindro_OI_lejos,
+            medida.Eje_OI_lejos,
+            medida.Agudeza_visual_OI_lejos,
+            medida.Esfera_OD_cerca,
+            medida.Cilindro_OD_cerca,
+            medida.Eje_OD_cerca,
+            medida.Agudeza_visual_OD_cerca,
+            medida.Esfera_OI_cerca,
+            medida.Cilindro_OI_cerca,
+            medida.Eje_OI_cerca,
+            medida.Agudeza_visual_OI_cerca,
+        ),
+    )
+    conn.commit()
+    return {"id": cursor.lastrowid, **medida.dict()}
+
+
+@app.put("/medidas/{id}")
+def update_medida(id: int, medida: Medida):
     """
-    Crea y guarda los detalles ópticos asociados a un cliente.
+    Actualiza una medida en la base de datos.
 
     Parámetros:
-    - cliente_id (int): ID del cliente al que se asociarán los detalles ópticos.
-    - detalles_opticos (DetallesOpticosCreate): Detalles ópticos a guardar.
+    - id (int): El ID de la medida a actualizar.
+    - medida (Medida): Objeto Medida con los datos actualizados.
 
     Retorna:
-    - dict: Información del nuevo registro creado.
+    - dict: Un diccionario con el mensaje de éxito de la actualización.
+
+    Lanza:
+    - HTTPException: Si no se encuentra la medida con el ID especificado.
     """
-    conn = get_db_connection()
+    conn = DatabaseConnection().get_connection()
     cursor = conn.cursor()
+    cursor.execute(
+        """
+        UPDATE medidas
+        SET Esfera_OD_lejos = ?,
+            Cilindro_OD_lejos = ?,
+            Eje_OD_lejos = ?,
+            Agudeza_visual_OD_lejos = ?,
+            Esfera_OI_lejos = ?,
+            Cilindro_OI_lejos = ?,
+            Eje_OI_lejos = ?,
+            Agudeza_visual_OI_lejos = ?,
+            Esfera_OD_cerca = ?,
+            Cilindro_OD_cerca = ?,
+            Eje_OD_cerca = ?,
+            Agudeza_visual_OD_cerca = ?,
+            Esfera_OI_cerca = ?,
+            Cilindro_OI_cerca = ?,
+            Eje_OI_cerca = ?,
+            Agudeza_visual_OI_cerca = ?
+        WHERE Id = ?
+        """,
+        (
+            medida.Esfera_OD_lejos,
+            medida.Cilindro_OD_lejos,
+            medida.Eje_OD_lejos,
+            medida.Agudeza_visual_OD_lejos,
+            medida.Esfera_OI_lejos,
+            medida.Cilindro_OI_lejos,
+            medida.Eje_OI_lejos,
+            medida.Agudeza_visual_OI_lejos,
+            medida.Esfera_OD_cerca,
+            medida.Cilindro_OD_cerca,
+            medida.Eje_OD_cerca,
+            medida.Agudeza_visual_OD_cerca,
+            medida.Esfera_OI_cerca,
+            medida.Cilindro_OI_cerca,
+            medida.Eje_OI_cerca,
+            medida.Agudeza_visual_OI_cerca,
+            id,
+        ),
+    )
+    conn.commit()
+    if cursor.rowcount < 1:
+        raise HTTPException(status_code=404, detail="Medida no encontrada")
+    return {"message": "Medida actualizada"}
+
+
+@app.delete("/medidas/{id}")
+def delete_medida(id: int):
+    """
+    Elimina una medida de la base de datos.
+
+    Parámetros:
+    - id: int, el ID de la medida a eliminar.
+
+    Retorna:
+    - dict: Un diccionario con el mensaje de éxito de la eliminación.
+
+    Lanza:
+    - HTTPException: Si no se encuentra la medida con el ID especificado.
+    """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+    cursor.execute("DELETE FROM medidas WHERE Id = ?", (id,))
+    conn.commit()
+    if cursor.rowcount < 1:
+        raise HTTPException(status_code=404, detail="Medida no encontrada")
+    return {"message": "Medida eliminada"}
 
-    # Verificar si el cliente existe
-    cursor.execute("SELECT * FROM cliente WHERE Id = ?", (cliente_id,))
-    cliente = cursor.fetchone()
-    if not cliente:
-        conn.close()
-        raise HTTPException(status_code=404, detail="Cliente no encontrado")
 
-    # Insertar detalles ópticos asociados al cliente
+@app.get("/cliente_medidas")
+def get_cliente_medidas():
+    """
+    Obtiene todas las medidas de los clientes.
+
+    Returns:
+        list: Lista de todas las medidas de los clientes.
+    """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM cliente_medidas")
+    cliente_medidas = cursor.fetchall()
+    return cliente_medidas
+
+
+@app.get("/cliente_medidas/{id}")
+def get_cliente_medida(id: int):
+    """
+    Obtiene los datos de una medida de cliente específica.
+
+    Parámetros:
+    - id: int: El ID de la medida de cliente a obtener.
+
+    Retorna:
+    - dict: Un diccionario con los datos de la medida de cliente.
+
+    Lanza:
+    - HTTPException: Si la medida de cliente no se encuentra.
+
+    """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM cliente_medidas WHERE id_cliente_medidas = ?", (id,))
+    cliente_medida = cursor.fetchone()
+    if cliente_medida:
+        return cliente_medida
+    raise HTTPException(status_code=404, detail="Cliente_medida no encontrada")
+
+
+class Cliente_Medida(BaseModel):
+    id_cliente: int
+    id_medidas: int
+
+
+@app.post("/cliente_medidas")
+def create_cliente_medida(cliente_medida: Cliente_Medida):
+    """
+    Crea un nuevo registro de cliente_medida en la base de datos.
+
+    Args:
+        cliente_medida (Cliente_Medida): Objeto que contiene los datos del cliente_medida.
+
+    Returns:
+        dict: Diccionario con el ID del registro creado y los datos del cliente_medida.
+    """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
     cursor.execute(
         """
-        INSERT INTO detalles_opticos (
-            Esfera_OD_lejos, Cilindro_OD_lejos, Eje_OD_lejos, Agudeza_visual_OD_lejos,
-            Esfera_OI_lejos, Cilindro_OI_lejos, Eje_OI_lejos, Agudeza_visual_OI_lejos,
-            Esfera_OD_cerca, Cilindro_OD_cerca, Eje_OD_cerca, Agudeza_visual_OD_cerca,
-            Esfera_OI_cerca, Cilindro_OI_cerca, Eje_OI_cerca, Agudeza_visual_OI_cerca,
-            Id_cliente
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    """,
+        INSERT INTO cliente_medidas (id_cliente, id_medidas)
+        VALUES (?, ?)
+        """,
         (
-            detalles_opticos.Esfera_OD_lejos,
-            detalles_opticos.Cilindro_OD_lejos,
-            detalles_opticos.Eje_OD_lejos,
-            detalles_opticos.Agudeza_visual_OD_lejos,
-            detalles_opticos.Esfera_OI_lejos,
-            detalles_opticos.Cilindro_OI_lejos,
-            detalles_opticos.Eje_OI_lejos,
-            detalles_opticos.Agudeza_visual_OI_lejos,
-            detalles_opticos.Esfera_OD_cerca,
-            detalles_opticos.Cilindro_OD_cerca,
-            detalles_opticos.Eje_OD_cerca,
-            detalles_opticos.Agudeza_visual_OD_cerca,
-            detalles_opticos.Esfera_OI_cerca,
-            detalles_opticos.Cilindro_OI_cerca,
-            detalles_opticos.Eje_OI_cerca,
-            detalles_opticos.Agudeza_visual_OI_cerca,
-            cliente_id,
+            cliente_medida.id_cliente,
+            cliente_medida.id_medidas,
         ),
     )
+    conn.commit()
+    return {"id": cursor.lastrowid, **cliente_medida.dict()}
+
+
+@app.put("/cliente_medidas/{id}")
+def update_cliente_medida(id: int, cliente_medida: Cliente_Medida):
+    """
+    Actualiza una medida de cliente en la base de datos.
+
+    Parámetros:
+    - id: int: El ID de la medida de cliente a actualizar.
+    - cliente_medida: Cliente_Medida: Objeto que contiene los datos de la medida de cliente actualizada.
 
-    # Obtener el ID del nuevo registro
-    nuevo_registro_id = cursor.lastrowid
+    Retorna:
+    - dict: Un diccionario con el mensaje de éxito si la medida de cliente se actualizó correctamente.
 
-    # Confirmar los cambios y cerrar la conexión
+    Lanza:
+    - HTTPException: Si la medida de cliente no se encuentra en la base de datos.
+    """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+    cursor.execute(
+        """
+        UPDATE cliente_medidas
+        SET id_cliente = ?,
+            id_medidas = ?
+        WHERE id_cliente_medidas = ?
+        """,
+        (
+            cliente_medida.id_cliente,
+            cliente_medida.id_medidas,
+            id,
+        ),
+    )
     conn.commit()
-    conn.close()
+    if cursor.rowcount < 1:
+        raise HTTPException(status_code=404, detail="Cliente_medida no encontrada")
+    return {"message": "Cliente_medida actualizada"}
 
-    # Devolver la información del nuevo registro
-    return {"Id": nuevo_registro_id, **detalles_opticos.dict()}
 
+@app.delete("/cliente_medidas/{id}")
+def delete_cliente_medida(id: int):
+    """
+    Elimina una medida de cliente en la base de datos.
 
-# PUT /detalles_opticos
-# Modelo Pydantic para los detalles ópticos
-class DetallesOpticosUpdate(BaseModel):
-    Esfera_OD_lejos: str
-    Cilindro_OD_lejos: str
-    Eje_OD_lejos: str
-    Agudeza_visual_OD_lejos: str
-    Esfera_OI_lejos: str
-    Cilindro_OI_lejos: str
-    Eje_OI_lejos: str
-    Agudeza_visual_OI_lejos: str
-    Esfera_OD_cerca: str
-    Cilindro_OD_cerca: str
-    Eje_OD_cerca: str
-    Agudeza_visual_OD_cerca: str
-    Esfera_OI_cerca: str
-    Cilindro_OI_cerca: str
-    Eje_OI_cerca: str
-    Agudeza_visual_OI_cerca: str
+    Parámetros:
+    - id: int, el ID de la medida de cliente a eliminar.
+
+    Retorna:
+    - dict: Un diccionario con el mensaje de éxito de eliminación.
+
+    Lanza:
+    - HTTPException: Si no se encuentra la medida de cliente con el ID especificado.
+    """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+    cursor.execute("DELETE FROM cliente_medidas WHERE id_cliente_medidas = ?", (id,))
+    conn.commit()
+    if cursor.rowcount < 1:
+        raise HTTPException(status_code=404, detail="Cliente_medida no encontrada")
+    return {"message": "Cliente_medida eliminada"}
+
+
+@app.get("/prescripciones")
+def get_prescripciones():
+    """
+    Obtiene todas las prescripciones de la base de datos.
+
+    Returns:
+        list: Lista de todas las prescripciones.
+    """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+    cursor.execute("SELECT * FROM prescripcion")
+    prescripciones = cursor.fetchall()
+    return prescripciones
 
 
-# Ruta para actualizar detalles ópticos
-@app.put("/detalles_opticos/{detalles_id}", response_model=dict)
-def update_detalles_opticos(
-    detalles_id: int, detalles_opticos: DetallesOpticosUpdate = Body(...)
-):
+@app.get("/prescripciones/{id}")
+def get_prescripcion(id: int):
     """
-    Actualiza los detalles ópticos en la base de datos.
+    Obtiene una prescripción por su ID.
 
     Parámetros:
-    - detalles_id: int - El ID de los detalles ópticos a actualizar.
-    - detalles_opticos: DetallesOpticosUpdate - Los detalles ópticos actualizados.
+    - id (int): El ID de la prescripción a obtener.
 
     Retorna:
-    - dict: Un diccionario con el mensaje de éxito y los detalles ópticos actualizados.
+    - dict: Un diccionario con la información de la prescripción.
+
+    Lanza:
+    - HTTPException: Si no se encuentra la prescripción con el ID especificado.
     """
-    conn = get_db_connection()
+    conn = DatabaseConnection().get_connection()
     cursor = conn.cursor()
+    cursor.execute("SELECT * FROM prescripcion WHERE id_prescripcion = ?", (id,))
+    prescripcion = cursor.fetchone()
+    if prescripcion:
+        return prescripcion
+    raise HTTPException(status_code=404, detail="Prescripcion no encontrada")
+
+
+class Prescripcion(BaseModel):
+    lunas: str
+    montura: str
+    fecha: str
+    id_cliente_medidas: int
+
 
-    # Verificar si los detalles ópticos existen
-    cursor.execute("SELECT * FROM detalles_opticos WHERE Id = ?", (detalles_id,))
-    detalles_existen = cursor.fetchone()
-    if not detalles_existen:
-        conn.close()
-        raise HTTPException(status_code=404, detail="Detalles ópticos no encontrados")
+@app.post("/prescripciones")
+def create_prescripcion(prescripcion: Prescripcion):
+    """
+    Crea una nueva prescripción en la base de datos.
+
+    Args:
+        prescripcion (Prescripcion): Objeto Prescripcion que contiene los datos de la prescripción.
 
-    # Actualizar los detalles ópticos
+    Returns:
+        dict: Un diccionario que contiene el ID de la prescripción creada y los datos de la prescripción.
+    """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
     cursor.execute(
         """
-        UPDATE detalles_opticos SET
-            Esfera_OD_lejos = ?, Cilindro_OD_lejos = ?, Eje_OD_lejos = ?, Agudeza_visual_OD_lejos = ?,
-            Esfera_OI_lejos = ?, Cilindro_OI_lejos = ?, Eje_OI_lejos = ?, Agudeza_visual_OI_lejos = ?,
-            Esfera_OD_cerca = ?, Cilindro_OD_cerca = ?, Eje_OD_cerca = ?, Agudeza_visual_OD_cerca = ?,
-            Esfera_OI_cerca = ?, Cilindro_OI_cerca = ?, Eje_OI_cerca = ?, Agudeza_visual_OI_cerca = ?
-        WHERE Id = ?
-    """,
+        INSERT INTO prescripcion (lunas, montura, fecha, id_cliente_medidas)
+        VALUES (?, ?, ?, ?)
+        """,
         (
-            detalles_opticos.Esfera_OD_lejos,
-            detalles_opticos.Cilindro_OD_lejos,
-            detalles_opticos.Eje_OD_lejos,
-            detalles_opticos.Agudeza_visual_OD_lejos,
-            detalles_opticos.Esfera_OI_lejos,
-            detalles_opticos.Cilindro_OI_lejos,
-            detalles_opticos.Eje_OI_lejos,
-            detalles_opticos.Agudeza_visual_OI_lejos,
-            detalles_opticos.Esfera_OD_cerca,
-            detalles_opticos.Cilindro_OD_cerca,
-            detalles_opticos.Eje_OD_cerca,
-            detalles_opticos.Agudeza_visual_OD_cerca,
-            detalles_opticos.Esfera_OI_cerca,
-            detalles_opticos.Cilindro_OI_cerca,
-            detalles_opticos.Eje_OI_cerca,
-            detalles_opticos.Agudeza_visual_OI_cerca,
-            detalles_id,
+            prescripcion.lunas,
+            prescripcion.montura,
+            prescripcion.fecha,
+            prescripcion.id_cliente_medidas,
         ),
     )
+    conn.commit()
+    return {"id": cursor.lastrowid, **prescripcion.dict()}
+
+
+@app.put("/prescripciones/{id}")
+def update_prescripcion(id: int, prescripcion: Prescripcion):
+    """
+    Actualiza una prescripción existente en la base de datos.
+
+    Parámetros:
+    - id (int): El ID de la prescripción a actualizar.
+    - prescripcion (Prescripcion): Objeto Prescripcion con los datos actualizados.
+
+    Retorna:
+    - dict: Un diccionario con el mensaje de éxito de la actualización.
 
-    # Confirmar los cambios y cerrar la conexión
+    Lanza:
+    - HTTPException: Si no se encuentra la prescripción con el ID especificado.
+    """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+    cursor.execute(
+        """
+        UPDATE prescripcion
+        SET lunas = ?,
+            montura = ?,
+            fecha = ?,
+            id_cliente_medidas = ?
+        WHERE id_prescripcion = ?
+        """,
+        (
+            prescripcion.lunas,
+            prescripcion.montura,
+            prescripcion.fecha,
+            prescripcion.id_cliente_medidas,
+            id,
+        ),
+    )
     conn.commit()
-    conn.close()
+    if cursor.rowcount < 1:
+        raise HTTPException(status_code=404, detail="Prescripcion no encontrada")
+    return {"message": "Prescripcion actualizada"}
+
+
+@app.delete("/prescripciones/{id}")
+def delete_prescripcion(id: int):
+    """
+    Elimina una prescripción de la base de datos.
+
+    Parámetros:
+    - id (int): El ID de la prescripción a eliminar.
 
-    # Devolver la información actualizada
-    return {
-        "message": "Detalles ópticos actualizados correctamente",
-        **detalles_opticos.dict(),
-    }
+    Retorna:
+    - dict: Un diccionario con el mensaje de éxito.
+
+    Lanza:
+    - HTTPException: Si no se encuentra la prescripción con el ID especificado.
+    """
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+    cursor.execute("DELETE FROM prescripcion WHERE id_prescripcion = ?", (id,))
+    conn.commit()
+    if cursor.rowcount < 1:
+        raise HTTPException(status_code=404, detail="Prescripcion no encontrada")
+    return {"message": "Prescripcion eliminada"}