mejoras dividiendo el proyecto en partes

.gitignore

@@ -8,3 +8,6 @@ test4.py
 test5.py
 test6.py
 .venv
+# añadimos los archivos que queremos ignorar optica_copia.db optica.db
+optica.db
+optica_copia.db

Optica.session.sql

@@ -1,4 +0,0 @@
-SELECT *
-FROM Prescripcion
-ORDER BY id_prescripcion DESC
-LIMIT 1;

app.py

@@ -1,27 +1,7 @@
 # uvicorn app:app --host localhost --port 7860 --reload
-# librerias propias del lenguaje
-from datetime import datetime
-from datetime import date
-import os
-
-# librerias para la API
-from pydantic import BaseModel
-from fastapi import FastAPI, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse
-
-# librerias para el pdf
-from reportlab.pdfgen import canvas
-from reportlab.lib.pagesizes import letter
-from reportlab.pdfbase import pdfmetrics
-from reportlab.pdfbase.ttfonts import TTFont
-from reportlab.platypus import Table, TableStyle
-
-# importar librerias para la conexion a la base de datos
-from queue import Queue
-import sqlite3
-import threading
-
+from library.librerias import *
+from database.conexion import DatabaseConnection
+from routers.routers import *
 
 app = FastAPI()
 
@@ -34,57 +14,25 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-
-class DatabaseConnection:
-    """
-    Clase para gestionar las conexiones a la base de datos con un pool.
-    """
-
-    _instance = None
-    _lock = threading.Lock()
-    _connection_pool = Queue(maxsize=5)
-
-    def __new__(cls):
-        """
-        Crea una nueva instancia de la clase si no existe.
-        """
-        with cls._lock:
-            if cls._instance is None:
-                cls._instance = super().__new__(cls)
-                cls._instance.conn = cls._instance._create_connection()
-        return cls._instance
-
-    def _create_connection(self):
-        """
-        Crea una conexión a la base de datos.
-        """
-        if not self._connection_pool.empty():
-            return self._connection_pool.get()
-        else:
-            connection = sqlite3.connect("optica_copia.db")
-            connection.row_factory = sqlite3.Row
-            return connection
-
-    def get_connection(self):
-        """
-        Obtener el objeto de conexión de la base de datos.
-        """
-        return self._instance._create_connection()
-
-    def release_connection(self):
-        """
-        Liberar la conexión de nuevo al pool.
-        """
-        if self._instance is not None:
-            self._connection_pool.put(self._instance.conn)
-            self._instance.conn = None  # Marcar la instancia como sin conexión
-
-
 # Cargar varias tipografías
 pdfmetrics.registerFont(TTFont("Craftcoke", "./font/Craftcoke.ttf"))
 pdfmetrics.registerFont(TTFont("Oregon", "./font/Oregon.ttf"))
 pdfmetrics.registerFont(TTFont("Roboto", "./font/Roboto.ttf"))
 
+# Routers
+
+app.router.include_router(roles.router)
+app.router.include_router(usuarios.router)
+app.router.include_router(clientes.router)
+app.router.include_router(medidas.router)
+app.router.include_router(prescripciones.router)
+app.router.include_router(lunas_pedido.router)
+app.router.include_router(monturas.router)
+app.router.include_router(monturas_inventario.router)
+app.router.include_router(boletas.router)
+app.router.include_router(comprobante_pago.router)
+app.router.include_router(monturas_pedido.router)
+
 
 # saludo
 @app.get("/")
@@ -92,2151 +40,5 @@ def read_root():
     return {"mensaje": "API de la óptica del curso de ADS"}
 
 
-"""
-CREATE TABLE Roles (
-  id_rol INTEGER PRIMARY KEY AUTOINCREMENT,
-  rol VARCHAR
-)
-"""
-
-
-# get/roles -> obtener todos los roles con with connection as conn, manejo de errores
-@app.get("/roles")
-def get_roles():
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM Roles")
-            roles = cursor.fetchall()
-            if roles:
-                return roles
-            else:
-                raise HTTPException(status_code=404, detail="Roles no encontrado")
-    except Exception as e:
-        print(e)
-        return []
-
-
-@app.get("/roles/{id_rol}")
-def get_rol(id_rol: int):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM Roles WHERE id_rol = ?", (id_rol,))
-            rol = cursor.fetchone()
-            if rol:
-                return rol
-            else:
-                raise HTTPException(status_code=404, detail="Rol no encontrado")
-    except Exception as e:
-        print(e)
-        return []
-
-
-# clase y metodo post para buscar rol por nombre
-class RolNombre(BaseModel):
-    rol: str
-
-
-@app.post("/roles/busqueda")
-def buscar_rol(rol: RolNombre):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM Roles WHERE rol = ?", (rol.rol,))
-            rol = cursor.fetchone()
-            # retornar el rol encontrado o un mensaje de error con HTTPException
-            if rol:
-                return rol
-            else:
-                raise HTTPException(status_code=404, detail="Rol no encontrado")
-    except Exception as e:
-        print(e)
-        return []
-
-
-# post/roles -> crear un rol con una clase pydantic
-class Rol(BaseModel):
-    rol: str
-
-
-# post/roles -> crear un rol con una clase pydantic
-@app.post("/roles")
-def create_rol(rol: Rol):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("INSERT INTO Roles (rol) VALUES (?)", (rol.rol,))
-            conn.commit()
-            return {"mensaje": "Rol creado exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# put/roles -> actualizar un rol con una clase pydantic
-class RolUpdate(BaseModel):
-    id_rol: int
-    rol: str
-
-
-@app.put("/roles")
-def update_rol(rol: RolUpdate):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "UPDATE Roles SET rol = ? WHERE id_rol = ?", (rol.rol, rol.id_rol)
-            )
-            conn.commit()
-            return {"mensaje": "Rol actualizado exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# delete/roles -> eliminar un rol con una clase pydantic
-class RolDelete(BaseModel):
-    id_rol: int
-
-
-@app.delete("/roles")
-def delete_rol(rol: RolDelete):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("DELETE FROM Roles WHERE id_rol = ?", (rol.id_rol,))
-            conn.commit()
-            return {"mensaje": "Rol eliminado exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-"""
-CREATE TABLE Usuario (
-  id_usuario INTEGER PRIMARY KEY AUTOINCREMENT,
-  nombre_usuario VARCHAR,
-  dni VARCHAR,
-  clave VARCHAR,
-  id_rol INTEGER REFERENCES Roles(id_rol),
-  estado VARCHAR
-)
-"""
-
-
-# get/usuarios -> obtener todos los usuarios con with connection as conn, manejo de errores
-@app.get("/usuarios")
-def get_usuarios():
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM Usuario")
-            usuarios = cursor.fetchall()
-            return usuarios
-    except Exception as e:
-        print(e)
-        return []
-
-
-# get/usuarios/{id_usuario} -> obtener un usuario por id
-@app.get("/usuarios/{id_usuario}")
-def get_usuario(id_usuario: int):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM Usuario WHERE id_usuario = ?", (id_usuario,))
-            usuario = cursor.fetchone()
-            return usuario
-    except Exception as e:
-        print(e)
-        return []
-
-
-# metodo de busqueda de usuario por nombre con like, manejo de errores y clase pydantic
-class UsuarioNombre(BaseModel):
-    nombre_usuario: str
-
-
-# post/usuarios/busqueda -> buscar usuario por nombre con like
-@app.post("/usuarios/busqueda")
-def buscar_usuario(usuario: UsuarioNombre):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "SELECT * FROM Usuario WHERE nombre_usuario LIKE ?",
-                ["%" + usuario.nombre_usuario + "%"],
-            )
-            usuario = cursor.fetchall()
-            if usuario:
-                return usuario
-            else:
-                raise HTTPException(status_code=404, detail="Usuario no encontrado")
-    except Exception as e:
-        print(e)
-        return []
-
-
-# post/usuarios -> crear un usuario con una clase pydantic
-class Usuario(BaseModel):
-    nombre_usuario: str
-    dni: str
-    clave: str
-    id_rol: int
-    estado: str
-
-
-@app.post("/usuarios")
-def create_usuario(usuario: Usuario):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "INSERT INTO Usuario (nombre_usuario, dni, clave, id_rol, estado) VALUES (?, ?, ?, ?, ?)",
-                (
-                    usuario.nombre_usuario,
-                    usuario.dni,
-                    usuario.clave,
-                    usuario.id_rol,
-                    usuario.estado,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Usuario creado exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# put/usuarios -> actualizar un usuario con una clase pydantic
-class UsuarioUpdate(BaseModel):
-    id_usuario: int
-    nombre_usuario: str
-    dni: str
-    clave: str
-    id_rol: int
-    estado: str
-
-
-@app.put("/usuarios")
-def update_usuario(usuario: UsuarioUpdate):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "UPDATE Usuario SET nombre_usuario = ?, dni = ?, clave = ?, id_rol = ?, estado = ? WHERE id_usuario = ?",
-                (
-                    usuario.nombre_usuario,
-                    usuario.dni,
-                    usuario.clave,
-                    usuario.id_rol,
-                    usuario.estado,
-                    usuario.id_usuario,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Usuario actualizado exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# delete/usuarios -> eliminar un usuario con una clase pydantic
-class UsuarioDelete(BaseModel):
-    id_usuario: int
-
-
-@app.delete("/usuarios")
-def delete_usuario(usuario: UsuarioDelete):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM Usuario WHERE id_usuario = ?", (usuario.id_usuario,)
-            )
-            conn.commit()
-            return {"mensaje": "Usuario eliminado exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-"""
-CREATE TABLE Cliente (
-  id_cliente INTEGER PRIMARY KEY AUTOINCREMENT,
-  nombres_y_apellidos VARCHAR,
-  edad INTEGER,
-  telefono INTEGER,
-  direccion VARCHAR
-)
-"""
-
-
-# get/clientes -> obtener todos los clientes con with connection as conn, manejo de errores
-@app.get("/clientes")
-def get_clientes():
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM Cliente")
-            clientes = cursor.fetchall()
-            return clientes
-    except Exception as e:
-        print(e)
-        return []
-
-
-@app.get("/clientes/{id_cliente}")
-def get_cliente(id_cliente: int):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM Cliente WHERE id_cliente = ?", (id_cliente,))
-            cliente = cursor.fetchone()
-            return cliente
-    except Exception as e:
-        print(e)
-        return []
-
-
-# metodo de busqueda de cliente por nombre con like, manejo de errores y clase pydantic
-class ClienteNombre(BaseModel):
-    nombres_y_apellidos: str
-
-
-@app.post("/clientes/busqueda")
-def post_cliente_busqueda(cliente: ClienteNombre):
-    try:
-        conn = DatabaseConnection().get_connection()
-        cursor = conn.cursor()
-        cursor.execute(
-            "SELECT * FROM Cliente WHERE nombres_y_apellidos LIKE ?",
-            ["%" + cliente.nombres_y_apellidos + "%"],
-        )
-        cliente = cursor.fetchall()
-        if cliente:
-            return cliente
-        else:
-            raise HTTPException(status_code=404, detail="Cliente no encontrado")
-    except Exception as e:
-        print(e)
-        return []
-
-
-# post/clientes -> crear un cliente con una clase pydantic
-class Cliente(BaseModel):
-    nombres_y_apellidos: str
-    edad: int
-    telefono: int
-    direccion: str
-
-
-@app.post("/clientes")
-def create_cliente(cliente: Cliente):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "INSERT INTO Cliente (nombres_y_apellidos, edad, telefono, direccion) VALUES (?, ?, ?, ?)",
-                (
-                    cliente.nombres_y_apellidos,
-                    cliente.edad,
-                    cliente.telefono,
-                    cliente.direccion,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Cliente creado exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# put/clientes -> actualizar un cliente con una clase pydantic
-class ClienteUpdate(BaseModel):
-    id_cliente: int
-    nombres_y_apellidos: str
-    edad: int
-    telefono: int
-    direccion: str
-
-
-@app.put("/clientes")
-def update_cliente(cliente: ClienteUpdate):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "UPDATE Cliente SET nombres_y_apellidos = ?, edad = ?, telefono = ?, direccion = ? WHERE id_cliente = ?",
-                (
-                    cliente.nombres_y_apellidos,
-                    cliente.edad,
-                    cliente.telefono,
-                    cliente.direccion,
-                    cliente.id_cliente,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Cliente actualizado exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# delete/clientes -> eliminar un cliente con una clase pydantic
-class ClienteDelete(BaseModel):
-    id_cliente: int
-
-
-# delete/clientes -> eliminar un cliente con una clase pydantic
-@app.delete("/clientes")
-def delete_cliente(cliente: ClienteDelete):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM Cliente WHERE id_cliente = ?", (cliente.id_cliente,)
-            )
-            conn.commit()
-            return {"mensaje": "Cliente eliminado exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# Define tu clase Pydantic para el modelo de datos
-class PrescripcionId(BaseModel):
-    id_prescripcion: int
-
-
-# Define tu método de búsqueda de cliente por id de prescripción con manejo de errores y clase Pydantic
-@app.post("/clientes/prescripcion")
-def get_cliente_por_prescripcion(prescripcion_id: PrescripcionId):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            # Consulta SQL para obtener el cliente a partir del id de la prescripción
-            cursor.execute(
-                """
-                SELECT c.* 
-                FROM Cliente c
-                JOIN Medidas m ON c.id_cliente = m.id_cliente
-                JOIN Prescripcion p ON m.id_medidas = p.id_medidas
-                WHERE p.id_prescripcion = ?
-                """,
-                [prescripcion_id.id_prescripcion],
-            )
-
-            cliente = cursor.fetchone()
-
-            if cliente:
-                return cliente
-            else:
-                raise HTTPException(
-                    status_code=404,
-                    detail="Cliente no encontrado para la prescripción proporcionada",
-                )
-
-    except Exception as e:
-        print(e)
-        return []
-
-
-"""
-CREATE TABLE Medidas (
-  id_medidas INTEGER PRIMARY KEY AUTOINCREMENT,
-  Esfera_OD_lejos REAL,
-  Cilindro_OD_lejos REAL,
-  Eje_OD_lejos REAL,
-  Agudeza_visual_OD_lejos REAL,
-  Esfera_OI_lejos REAL,
-  Cilindro_OI_lejos REAL,
-  Eje_OI_lejos REAL,
-  Agudeza_visual_OI_lejos REAL,
-  Esfera_OD_cerca REAL,
-  Cilindro_OD_cerca REAL,
-  Eje_OD_cerca REAL,
-  Agudeza_visual_OD_cerca REAL,
-  Esfera_OI_cerca REAL,
-  Cilindro_OI_cerca REAL,
-  Eje_OI_cerca REAL,
-  Agudeza_visual_OI_cerca REAL,
-  id_cliente INTEGER REFERENCES Cliente(id_cliente)
-)
-"""
-
-
-# get/medidas -> obtener todas las medidas con with connection as conn, manejo de errores
-@app.get("/medidas")
-def get_medidas():
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM Medidas")
-            medidas = cursor.fetchall()
-            return medidas
-    except Exception as e:
-        print(e)
-        return []
-
-
-# get/medidas/{id_medidas} -> obtener una medida por id
-@app.get("/medidas/{id_medidas}")
-def get_medida(id_medidas: int):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM Medidas WHERE id_medidas = ?", (id_medidas,))
-            medida = cursor.fetchone()
-            return medida
-    except Exception as e:
-        print(e)
-        return []
-
-
-# metodo de busqueda que sea por id_cliente y retorne las medidas asociadas a ese cliente con clase y metodo post
-class MedidasCliente(BaseModel):
-    id_cliente: int
-
-
-@app.post("/medidas/busqueda")
-def buscar_medida(medida: MedidasCliente):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "SELECT * FROM Medidas WHERE id_cliente = ?",
-                (medida.id_cliente,),
-            )
-            medida = cursor.fetchall()
-            if medida:
-                return medida
-            else:
-                raise HTTPException(status_code=404, detail="Medida no encontrada")
-    except Exception as e:
-        print(e)
-        return []
-
-
-# post/medidas -> crear una medida con una clase pydantic
-class Medida(BaseModel):
-    Esfera_OD_lejos: float
-    Cilindro_OD_lejos: float
-    Eje_OD_lejos: float
-    Agudeza_visual_OD_lejos: float
-    Esfera_OI_lejos: float
-    Cilindro_OI_lejos: float
-    Eje_OI_lejos: float
-    Agudeza_visual_OI_lejos: float
-    Esfera_OD_cerca: float
-    Cilindro_OD_cerca: float
-    Eje_OD_cerca: float
-    Agudeza_visual_OD_cerca: float
-    Esfera_OI_cerca: float
-    Cilindro_OI_cerca: float
-    Eje_OI_cerca: float
-    Agudeza_visual_OI_cerca: float
-    id_cliente: int
-
-
-@app.post("/medidas")
-def create_medida(medida: Medida):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            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, id_cliente) 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,
-                    medida.id_cliente,
-                ],
-            )
-            conn.commit()
-            return {"mensaje": "Medida creada correctamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# put/medidas -> actualizar una medida con una clase pydantic
-class MedidaUpdate(BaseModel):
-    id_medidas: int
-    Esfera_OD_lejos: float
-    Cilindro_OD_lejos: float
-    Eje_OD_lejos: float
-    Agudeza_visual_OD_lejos: float
-    Esfera_OI_lejos: float
-    Cilindro_OI_lejos: float
-    Eje_OI_lejos: float
-    Agudeza_visual_OI_lejos: float
-    Esfera_OD_cerca: float
-    Cilindro_OD_cerca: float
-    Eje_OD_cerca: float
-    Agudeza_visual_OD_cerca: float
-    Esfera_OI_cerca: float
-    Cilindro_OI_cerca: float
-    Eje_OI_cerca: float
-    Agudeza_visual_OI_cerca: float
-    id_cliente: int
-
-
-# metodo put de medidas con manejo de errores
-@app.put("/medidas")
-def update_medida(medida: MedidaUpdate):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            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 = ?, id_cliente = ? WHERE id_medidas = ?",
-                [
-                    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,
-                    medida.id_cliente,
-                    medida.id_medidas,
-                ],
-            )
-            conn.commit()
-            return {"mensaje": "Medida actualizada correctamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# delete/medidas -> eliminar una medida con una clase pydantic
-class MedidaDelete(BaseModel):
-    id_medidas: int
-
-
-# metodo delete de medidas con manejo de errores
-@app.delete("/medidas")
-def delete_medida(medida: MedidaDelete):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM Medidas WHERE id_medidas = ?", (medida.id_medidas,)
-            )
-            conn.commit()
-            return {"mensaje": "Medida eliminada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-"""
-CREATE TABLE Prescripcion (
-  id_prescripcion INTEGER PRIMARY KEY AUTOINCREMENT,
-  id_medidas INTEGER REFERENCES Medidas(id_medidas),
-  detalle_lunas VARCHAR,
-  fecha VARCHAR
-  
-)
-"""
-
-
-# get/prescripciones -> obtener todas las prescripciones con with connection as conn, manejo de errores
-@app.get("/prescripciones")
-def get_prescripciones():
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM Prescripcion")
-            prescripciones = cursor.fetchall()
-            return prescripciones
-    except Exception as e:
-        print(e)
-        return []
-
-
-@app.get("/prescripciones/ultimoregistro")
-def get_prescripciones():
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "SELECT * FROM Prescripcion ORDER BY id_prescripcion DESC LIMIT 1;"
-            )
-            prescripciones = cursor.fetchall()
-            return prescripciones
-    except Exception as e:
-        print(e)
-        return []
-
-
-# get/prescripciones/{id_prescripcion} -> obtener una prescripcion por id
-@app.get("/prescripciones/{id_prescripcion}")
-def get_prescripcion(id_prescripcion: int):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "SELECT * FROM Prescripcion WHERE id_prescripcion = ?",
-                (id_prescripcion,),
-            )
-            prescripcion = cursor.fetchone()
-            return prescripcion
-    except Exception as e:
-        print(e)
-        return []
-
-
-class Prescripcion(BaseModel):
-    id_medidas: int
-    detalle_lunas: str
-    fecha: str
-
-
-# post prescripcion con pydantic con retorna la todos los datos de la prescripcion
-@app.post("/prescripcion/ultimoRegistro")
-def post_prescripcion(prescripcion: Prescripcion):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "INSERT INTO Prescripcion (id_medidas, detalle_lunas, fecha) VALUES (?, ?, ?)",
-                (
-                    prescripcion.id_medidas,
-                    prescripcion.detalle_lunas,
-                    prescripcion.fecha,
-                ),
-            )
-            conn.commit()
-            cursor.execute(
-                "SELECT * FROM Prescripcion ORDER BY id_prescripcion DESC LIMIT 1;"
-            )
-            prescripciones = cursor.fetchall()
-            return prescripciones
-    except Exception as e:
-        print(e)
-        return []
-
-
-# metodo post de prescripciones con manejo de errores
-@app.post("/prescripciones")
-def create_prescripcion(prescripcion: Prescripcion):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "INSERT INTO Prescripcion (id_medidas, detalle_lunas, fecha) VALUES (?, ?, ?)",
-                (
-                    prescripcion.id_medidas,
-                    prescripcion.detalle_lunas,
-                    prescripcion.fecha,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Prescripcion creada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# put/prescripciones -> actualizar una prescripcion con una clase pydantic
-class PrescripcionUpdate(BaseModel):
-    id_prescripcion: int
-    id_medidas: int
-    detalle_lunas: str
-    fecha: str
-
-
-# metodo put de prescripciones con manejo de errores
-@app.put("/prescripciones")
-def update_prescripcion(prescripcion: PrescripcionUpdate):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "UPDATE Prescripcion SET id_medidas = ?, detalle_lunas = ?, fecha = ? WHERE id_prescripcion = ?",
-                (
-                    prescripcion.id_medidas,
-                    prescripcion.detalle_lunas,
-                    prescripcion.fecha,
-                    prescripcion.id_prescripcion,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Prescripcion actualizada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# delete/prescripciones -> eliminar una prescripcion con una clase pydantic
-class PrescripcionDelete(BaseModel):
-    id_prescripcion: int
-
-
-# metodo delete de prescripciones con manejo de errores
-@app.delete("/prescripciones")
-def delete_prescripcion(prescripcion: PrescripcionDelete):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM Prescripcion WHERE id_prescripcion = ?",
-                (prescripcion.id_prescripcion,),
-            )
-            conn.commit()
-            return {"mensaje": "Prescripcion eliminada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-def obtener_datos_prescripcion(id_prescripcion):
-    try:
-        conn = DatabaseConnection().get_connection()
-        cursor = conn.cursor()
-        query = """
-        SELECT
-            P.id_prescripcion,
-            P.fecha AS fecha_prescripcion,
-            P.detalle_lunas,
-            Me.Esfera_OD_lejos,
-            Me.Cilindro_OD_lejos,
-            Me.Eje_OD_lejos,
-            Me.Agudeza_visual_OD_lejos,
-            Me.Esfera_OI_lejos,
-            Me.Cilindro_OI_lejos,
-            Me.Eje_OI_lejos,
-            Me.Agudeza_visual_OI_lejos,
-            Me.Esfera_OD_cerca,
-            Me.Cilindro_OD_cerca,
-            Me.Eje_OD_cerca,
-            Me.Agudeza_visual_OD_cerca,
-            Me.Esfera_OI_cerca,
-            Me.Cilindro_OI_cerca,
-            Me.Eje_OI_cerca,
-            Me.Agudeza_visual_OI_cerca,
-            C.id_cliente,
-            C.nombres_y_apellidos,
-            C.edad,
-            C.telefono,
-            C.direccion
-        FROM
-            Prescripcion AS P
-        JOIN
-            Medidas AS Me ON P.id_medidas = Me.id_medidas
-        JOIN
-            Cliente AS C ON Me.id_cliente = C.id_cliente
-        WHERE
-            P.id_prescripcion = ?;
-        """
-        cursor.execute(query, (id_prescripcion,))
-        resultado = cursor.fetchone()
-        return resultado
-    except Exception as e:
-        print(e)
-        return []
-
-
-# crear endpoint para obtener los datos de la prescripción
-@app.get("/prescripcion/{id_prescripcion}")
-def obtener_datos_prescripcion_api(id_prescripcion: int):
-    datos_prescripcion = obtener_datos_prescripcion(id_prescripcion)
-    if datos_prescripcion:
-        # Crear un objeto de la clase DatosPrescripcion
-        obj_datos_prescripcion = DatosPrescripcion(*datos_prescripcion)
-        return obj_datos_prescripcion
-    else:
-        raise HTTPException(status_code=404, detail="Prescripción no encontrada")
-
-
-class DatosPrescripcion:
-    def __init__(
-        self,
-        id_prescripcion,
-        fecha_prescripcion,
-        detalle_lunas,
-        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,
-        nombres_y_apellidos,
-        edad,
-        telefono,
-        direccion,
-    ):
-        """
-        Clase que representa los datos de una prescripción.
-
-        Args:
-            id_prescripcion (int): El ID de la prescripción.
-            fecha_prescripcion (str): La fecha de la prescripción.
-            detalle_lunas (str): Los detalles de las lentes.
-            esfera_od_lejos (float): El valor de la esfera para el ojo derecho en visión lejana.
-            cilindro_od_lejos (float): El valor del cilindro para el ojo derecho en visión lejana.
-            eje_od_lejos (int): El valor del eje para el ojo derecho en visión lejana.
-            agudeza_visual_od_lejos (str): La agudeza visual para el ojo derecho en visión lejana.
-            esfera_oi_lejos (float): El valor de la esfera para el ojo izquierdo en visión lejana.
-            cilindro_oi_lejos (float): El valor del cilindro para el ojo izquierdo en visión lejana.
-            eje_oi_lejos (int): El valor del eje para el ojo izquierdo en visión lejana.
-            agudeza_visual_oi_lejos (str): La agudeza visual para el ojo izquierdo en visión lejana.
-            esfera_od_cerca (float): El valor de la esfera para el ojo derecho en visión cercana.
-            cilindro_od_cerca (float): El valor del cilindro para el ojo derecho en visión cercana.
-            eje_od_cerca (int): El valor del eje para el ojo derecho en visión cercana.
-            agudeza_visual_od_cerca (str): La agudeza visual para el ojo derecho en visión cercana.
-            esfera_oi_cerca (float): El valor de la esfera para el ojo izquierdo en visión cercana.
-            cilindro_oi_cerca (float): El valor del cilindro para el ojo izquierdo en visión cercana.
-            eje_oi_cerca (int): El valor del eje para el ojo izquierdo en visión cercana.
-            agudeza_visual_oi_cerca (str): La agudeza visual para el ojo izquierdo en visión cercana.
-            id_cliente (int): El ID del cliente.
-            nombres_y_apellidos (str): Los nombres y apellidos del cliente.
-            edad (int): La edad del cliente.
-            telefono (str): El número de teléfono del cliente.
-            direccion (str): La dirección del cliente.
-        """
-        self.id_prescripcion = id_prescripcion
-        self.fecha_prescripcion = fecha_prescripcion
-        self.detalle_lunas = detalle_lunas
-        self.esfera_od_lejos = esfera_od_lejos
-        self.cilindro_od_lejos = cilindro_od_lejos
-        self.eje_od_lejos = eje_od_lejos
-        self.agudeza_visual_od_lejos = agudeza_visual_od_lejos
-        self.esfera_oi_lejos = esfera_oi_lejos
-        self.cilindro_oi_lejos = cilindro_oi_lejos
-        self.eje_oi_lejos = eje_oi_lejos
-        self.agudeza_visual_oi_lejos = agudeza_visual_oi_lejos
-        self.esfera_od_cerca = esfera_od_cerca
-        self.cilindro_od_cerca = cilindro_od_cerca
-        self.eje_od_cerca = eje_od_cerca
-        self.agudeza_visual_od_cerca = agudeza_visual_od_cerca
-        self.esfera_oi_cerca = esfera_oi_cerca
-        self.cilindro_oi_cerca = cilindro_oi_cerca
-        self.eje_oi_cerca = eje_oi_cerca
-        self.agudeza_visual_oi_cerca = agudeza_visual_oi_cerca
-        self.id_cliente = id_cliente
-        self.nombres_y_apellidos_cliente = nombres_y_apellidos
-        self.edad_cliente = edad
-        self.telefono_cliente = telefono
-        self.direccion_cliente = direccion
-
-    def generar_pdf(self, filename):
-        """
-        Genera un archivo PDF con los datos de la prescripción.
-
-        Args:
-            filename (str): El nombre del archivo PDF a generar.
-        """
-        pdf = canvas.Canvas(filename)
-        pdf.setFont("Oregon", 12)
-        ubicacion_inicio = 780  # Posición inicial en y
-        pdf.drawCentredString(
-            300, ubicacion_inicio, "OPTICA ARTE VISUAL - PRESCRIPCIÓN"
-        )
-        pdf.drawString(
-            100,
-            ubicacion_inicio - 40,
-            f"Nombre del Cliente: {self.nombres_y_apellidos_cliente}",
-        )
-        pdf.drawString(
-            100, ubicacion_inicio - 60, f"Datos del cliente: {self.direccion_cliente}"
-        )
-        pdf.drawString(
-            100, ubicacion_inicio - 80, f"Número telefónico: {self.telefono_cliente}"
-        )
-        pdf.drawString(
-            100,
-            ubicacion_inicio - 100,
-            f"Código de prescripción: {self.id_prescripcion}",
-        )
-        pdf.drawString(100, ubicacion_inicio - 120, f"Fecha: {self.fecha_prescripcion}")
-        pdf.drawString(
-            100, ubicacion_inicio - 140, f"Descripción: {self.detalle_lunas}"
-        )
-        ubicacion_esfera = 150  # Posición inicial en x
-        ubicacion_cilindro = ubicacion_esfera + 65  # Posición inicial en x + 65
-        ubicacion_eje = ubicacion_cilindro + 75  # Posición anterior en x + 75
-        ubicacion_agudeza = ubicacion_eje + 70  # Posición anterior en x + 70
-        tabla_medidas = ubicacion_inicio - 170  # Posición inicial en y
-
-        pdf.drawString(ubicacion_esfera - 50, tabla_medidas, "Tabla de medidas:")
-        # Para el ojo izquierdo de lejos
-        pdf.drawString(
-            ubicacion_esfera + 100, tabla_medidas - 20, "Ojo izquierdo de lejos"
-        )
-        pdf.line(
-            x1=ubicacion_esfera,
-            y1=tabla_medidas - 25,
-            x2=ubicacion_esfera + 300,
-            y2=tabla_medidas - 25,
-        )
-        pdf.drawString(ubicacion_esfera, tabla_medidas - 40, "Esfera")
-        pdf.drawString(ubicacion_cilindro, tabla_medidas - 40, "Cilindro")
-        pdf.drawString(ubicacion_eje, tabla_medidas - 40, "Eje")
-        pdf.drawString(ubicacion_agudeza, tabla_medidas - 40, "Agudeza visual")
-        pdf.drawString(ubicacion_esfera, tabla_medidas - 60, f"{self.esfera_oi_lejos}")
-        pdf.drawString(
-            ubicacion_cilindro, tabla_medidas - 60, f"{self.cilindro_oi_lejos}"
-        )
-        pdf.drawString(ubicacion_eje, tabla_medidas - 60, f"{self.eje_oi_lejos}")
-        pdf.drawString(
-            ubicacion_agudeza, tabla_medidas - 60, f"{self.agudeza_visual_oi_lejos}"
-        )
-        # Para el ojo derecho de lejos
-        odl = tabla_medidas - 100  # Posición inicial en y
-        pdf.drawString(ubicacion_esfera + 100, odl, "Ojo derecho de lejos")
-        pdf.line(x1=ubicacion_esfera, y1=odl - 5, x2=ubicacion_esfera + 300, y2=odl - 5)
-        pdf.drawString(ubicacion_esfera, odl - 20, "Esfera")
-        pdf.drawString(ubicacion_cilindro, odl - 20, "Cilindro")
-        pdf.drawString(ubicacion_eje, odl - 20, "Eje")
-        pdf.drawString(ubicacion_agudeza, odl - 20, "Agudeza visual")
-        pdf.drawString(ubicacion_esfera, odl - 40, f"{self.esfera_od_lejos}")
-        pdf.drawString(ubicacion_cilindro, odl - 40, f"{self.cilindro_od_lejos}")
-        pdf.drawString(ubicacion_eje, odl - 40, f"{self.eje_od_lejos}")
-        pdf.drawString(ubicacion_agudeza, odl - 40, f"{self.agudeza_visual_od_lejos}")
-
-        oic = odl - 80  # Posición inicial en y
-        pdf.drawString(ubicacion_esfera + 100, oic, "Ojo izquierdo de cerca")
-        pdf.line(x1=ubicacion_esfera, y1=oic - 5, x2=ubicacion_esfera + 300, y2=oic - 5)
-        # Para el ojo izquierdo de cerca
-        pdf.drawString(ubicacion_esfera, oic - 20, "Esfera")
-        pdf.drawString(ubicacion_cilindro, oic - 20, "Cilindro")
-        pdf.drawString(ubicacion_eje, oic - 20, "Eje")
-        pdf.drawString(ubicacion_agudeza, oic - 20, "Agudeza visual")
-        pdf.drawString(ubicacion_esfera, oic - 40, f"{self.esfera_oi_cerca}")
-        pdf.drawString(ubicacion_cilindro, oic - 40, f"{self.cilindro_oi_cerca}")
-        pdf.drawString(ubicacion_eje, oic - 40, f"{self.eje_oi_cerca}")
-        pdf.drawString(ubicacion_agudeza, oic - 40, f"{self.agudeza_visual_oi_cerca}")
-        odc = oic - 80
-        pdf.drawString(ubicacion_esfera + 100, odc, "Ojo derecho de cerca")
-        pdf.line(x1=ubicacion_esfera, y1=odc - 5, x2=ubicacion_esfera + 300, y2=odc - 5)
-        # Para el ojo derecho de cerca
-        pdf.drawString(ubicacion_esfera, odc - 20, "Esfera")
-        pdf.drawString(ubicacion_cilindro, odc - 20, "Cilindro")
-        pdf.drawString(ubicacion_eje, odc - 20, "Eje")
-        pdf.drawString(ubicacion_agudeza, odc - 20, "Agudeza visual")
-        pdf.drawString(ubicacion_esfera, odc - 40, f"{self.esfera_od_cerca}")
-        pdf.drawString(ubicacion_cilindro, odc - 40, f"{self.cilindro_od_cerca}")
-        pdf.drawString(ubicacion_eje, odc - 40, f"{self.eje_od_cerca}")
-        pdf.drawString(ubicacion_agudeza, odc - 40, f"{self.agudeza_visual_od_cerca}")
-
-        # Calcular el centro de la página
-        centro_pagina = pdf._pagesize[0] / 2
-
-        # Texto y línea centrados
-        texto_firma = "        Firma o sello:         "
-        ancho_texto = pdf.stringWidth(texto_firma, "Helvetica", 12)
-        inicio_linea = centro_pagina - ancho_texto / 2
-        fin_linea = inicio_linea + ancho_texto
-        # ubicacion en y dependiendo de la tabla de medidas
-        firma_ubicacion = odc - 70
-        pdf.drawString(inicio_linea, firma_ubicacion, texto_firma)
-        pdf.line(inicio_linea, firma_ubicacion - 50, fin_linea, firma_ubicacion - 50)
-
-        pdf.save()
-        print(f"PDF generado: {filename}")
-
-
-# endpoint descargar prescripcion pdf con clase
-class PrescripcionPDF(BaseModel):
-    id_prescripcion: int
-
-
-@app.post("/prescripcion/pdf")
-def obtener_pdf_prescripcion_api(prescripcion: PrescripcionPDF):
-    datos_prescripcion = obtener_datos_prescripcion(prescripcion.id_prescripcion)
-    if datos_prescripcion:
-        # Crear un objeto de la clase DatosPrescripcion
-        obj_datos_prescripcion = DatosPrescripcion(*datos_prescripcion)
-        directorio_pdf = "pdf/prescripcion/"
-        os.makedirs(directorio_pdf, exist_ok=True)
-        # obtener la fecha de hoy
-        fecha_hoy = date.today()
-        # generar el nombre del archivo
-        nombre_archivo = f"{directorio_pdf}prescripcion_{prescripcion.id_prescripcion}_{fecha_hoy}.pdf"
-
-        obj_datos_prescripcion.generar_pdf(f"{nombre_archivo}")
-        return FileResponse(
-            nombre_archivo, media_type="application/pdf", filename=nombre_archivo
-        )
-    else:
-        raise HTTPException(status_code=404, detail="Prescripción no encontrada")
-
-
-# crear endpoint retornando la url del PDF con los datos de la prescripción
-@app.get("/prescripcion/pdf/{id_prescripcion}")
-def ver_prescripcion_pdf(id_prescripcion: int):
-    datos_prescripcion = obtener_datos_prescripcion(id_prescripcion)
-    if datos_prescripcion:
-        # Crear un objeto de la clase DatosPrescripcion
-        obj_datos_prescripcion = DatosPrescripcion(*datos_prescripcion)
-        directorio_pdf = "pdf/prescripcion/"
-        os.makedirs(directorio_pdf, exist_ok=True)
-        # obtener la fecha de hoy
-        fecha_hoy = date.today()
-        # generar el nombre del archivo
-        nombre_archivo = (
-            f"{directorio_pdf}prescripcion_{id_prescripcion}_{fecha_hoy}.pdf"
-        )
-        obj_datos_prescripcion.generar_pdf(f"{nombre_archivo}")
-        return FileResponse(path=nombre_archivo)
-    else:
-        raise HTTPException(status_code=404, detail="Prescripción no encontrada")
-
-
-# metodo get pdf de prescripcion
-@app.get("/prescripcion/descargarPDF/{id_prescripcion}")
-def descargar_prescripcion_pdf(id_prescripcion: int):
-    datos_prescripcion = obtener_datos_prescripcion(id_prescripcion)
-    if datos_prescripcion:
-        # Crear un objeto de la clase DatosPrescripcion
-        obj_datos_prescripcion = DatosPrescripcion(*datos_prescripcion)
-        directorio_pdf = "pdf/prescripcion/"
-        os.makedirs(directorio_pdf, exist_ok=True)
-        # obtener la fecha de hoy
-        fecha_hoy = date.today()
-        # generar el nombre del archivo
-        nombre_archivo = (
-            f"{directorio_pdf}prescripcion_{id_prescripcion}_{fecha_hoy}.pdf"
-        )
-        obj_datos_prescripcion.generar_pdf(f"{nombre_archivo}")
-        return FileResponse(
-            path=nombre_archivo, media_type="application/pdf", filename=nombre_archivo
-        )
-    else:
-        raise HTTPException(status_code=404, detail="Prescripción no encontrada")
-
-
-"""
-Table lunas_pedido {
-  id_lunas_pedido INTEGER [primary key, unique, increment]
-  id_prescripcion INTEGER [ref: > Prescripcion.id_prescripcion]
-  precio REAL
-  id_boleta INTEGER [ref: > boleta.id_boleta]
-  descripcion VARCHAR
-  cantidad INTEGER
-}
-"""
-
-
-# get
-@app.get("/lunas_pedido")
-def get_lunas_pedido():
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM lunas_pedido")
-            lunas_pedido = cursor.fetchall()
-            return lunas_pedido
-    except Exception as e:
-        print(e)
-        return []
-
-
-# post con pydantic
-class LunasPedido(BaseModel):
-    id_prescripcion: int
-    precio: float
-    id_boleta: int
-    descripcion: str
-    cantidad: int
-
-
-@app.post("/lunas_pedido")
-def create_lunas_pedido(lunas_pedido: LunasPedido):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "INSERT INTO lunas_pedido (id_prescripcion, precio, id_boleta, descripcion, cantidad) VALUES (?, ?, ?, ?, ?)",
-                (
-                    lunas_pedido.id_prescripcion,
-                    lunas_pedido.precio,
-                    lunas_pedido.id_boleta,
-                    lunas_pedido.descripcion,
-                    lunas_pedido.cantidad,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Lunas_pedido creada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# put con pydantic
-class LunasPedidoUpdate(BaseModel):
-    id_lunas_pedido: int
-    id_prescripcion: int
-    precio: float
-    id_boleta: int
-    descripcion: str
-    cantidad: int
-
-
-@app.put("/lunas_pedido")
-def update_lunas_pedido(lunas_pedido: LunasPedidoUpdate):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "UPDATE lunas_pedido SET id_prescripcion = ?, precio = ?, id_boleta = ?, descripcion = ?, cantidad = ? WHERE id_lunas_pedido = ?",
-                (
-                    lunas_pedido.id_prescripcion,
-                    lunas_pedido.precio,
-                    lunas_pedido.id_boleta,
-                    lunas_pedido.descripcion,
-                    lunas_pedido.cantidad,
-                    lunas_pedido.id_lunas_pedido,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Lunas_pedido actualizada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# delete con pydantic
-class LunasPedidoDelete(BaseModel):
-    id_lunas_pedido: int
-
-
-@app.delete("/lunas_pedido")
-def delete_lunas_pedido(lunas_pedido: LunasPedidoDelete):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM lunas_pedido WHERE id_lunas_pedido = ?",
-                (lunas_pedido.id_lunas_pedido,),
-            )
-            conn.commit()
-            return {"mensaje": "Lunas_pedido eliminada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-"""
-CREATE TABLE Montura (
-  id_montura INTEGER PRIMARY KEY AUTOINCREMENT,
-  nombre_montura VARCHAR,
-  imagen VARCHAR,
-  marca VARCHAR,
-  color VARCHAR,
-  material VARCHAR
-)
-"""
-
-
-# get/monturas -> obtener todas las monturas con with connection as conn, manejo de errores
-@app.get("/monturas")
-def get_monturas():
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM Montura")
-            monturas = cursor.fetchall()
-            return monturas
-    except Exception as e:
-        print(e)
-        return []
-
-
-# get/monturas/{id_montura} -> obtener una montura por id
-@app.get("/monturas/{id_montura}")
-def get_montura(id_montura: int):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM Montura WHERE id_montura = ?", (id_montura,))
-            montura = cursor.fetchone()
-            return montura
-    except Exception as e:
-        print(e)
-        return []
-
-
-# busqueda de montura por nombre con like, manejo de errores y clase pydantic
-class MonturaNombre(BaseModel):
-    nombre_montura: str
-
-
-# post/monturas/busqueda -> buscar montura por nombre
-@app.post("/monturas/busqueda")
-def buscar_montura(montura: MonturaNombre):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "SELECT * FROM Montura WHERE nombre_montura LIKE ?",
-                (montura.nombre_montura,),
-            )
-            montura = cursor.fetchall()
-            if montura:
-                return montura
-            else:
-                raise HTTPException(status_code=404, detail="Montura no encontrada")
-    except Exception as e:
-        print(e)
-        return []
-
-
-# post/monturas -> crear una montura con una clase pydantic
-class Montura(BaseModel):
-    nombre_montura: str
-    imagen: str
-    marca: str
-    color: str
-    material: str
-
-
-# metodo post de monturas con manejo de errores
-@app.post("/monturas")
-def create_montura(montura: Montura):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "INSERT INTO Montura (nombre_montura, imagen, marca, color, material) VALUES (?, ?, ?, ?, ?)",
-                (
-                    montura.nombre_montura,
-                    montura.imagen,
-                    montura.marca,
-                    montura.color,
-                    montura.material,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Montura creada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# put/monturas -> actualizar una montura con una clase pydantic
-class MonturaUpdate(BaseModel):
-    id_montura: int
-    nombre_montura: str
-    imagen: str
-    marca: str
-    color: str
-    material: str
-
-
-# metodo put de monturas con manejo de errores
-@app.put("/monturas")
-def update_montura(montura: MonturaUpdate):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "UPDATE Montura SET nombre_montura = ?, imagen = ?, marca = ?, color = ?, material = ? WHERE id_montura = ?",
-                (
-                    montura.nombre_montura,
-                    montura.imagen,
-                    montura.marca,
-                    montura.color,
-                    montura.material,
-                    montura.id_montura,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Montura actualizada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# delete/monturas -> eliminar una montura con una clase pydantic
-class MonturaDelete(BaseModel):
-    id_montura: int
-
-
-# metodo delete de monturas con manejo de errores
-@app.delete("/monturas")
-def delete_montura(montura: MonturaDelete):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM Montura WHERE id_montura = ?", (montura.id_montura,)
-            )
-            conn.commit()
-            return {"mensaje": "Montura eliminada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-"""
-CREATE TABLE Montura_inventario (
-  id_montura_inventario INTEGER PRIMARY KEY AUTOINCREMENT,
-  id_montura INTEGER REFERENCES Montura(id_montura),
-  precio_unit REAL,
-  stock INTEGER,
-  codigo VARCHAR
-)
-"""
-
-
-# get/monturas_inventario -> obtener todas las monturas_inventario con with connection as conn, manejo de errores
-@app.get("/monturas_inventario")
-def get_monturas_inventario():
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM Montura_inventario")
-            monturas_inventario = cursor.fetchall()
-            return monturas_inventario
-    except Exception as e:
-        print(e)
-        return []
-
-
-# get/monturas_inventario/{id_montura_inventario} -> obtener una montura_inventario por id
-@app.get("/monturas_inventario/{id_montura_inventario}")
-def get_montura_inventario(id_montura_inventario: int):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "SELECT * FROM Montura_inventario WHERE id_montura_inventario = ?",
-                (id_montura_inventario,),
-            )
-            montura_inventario = cursor.fetchone()
-            return montura_inventario
-    except Exception as e:
-        print(e)
-        return []
-
-
-# post/monturas_inventario -> crear una montura_inventario con una clase pydantic
-class Montura_inventario(BaseModel):
-    id_montura: int
-    precio_unit: float
-    stock: int
-    codigo: str
-
-
-# metodo post de monturas_inventario con manejo de errores
-@app.post("/monturas_inventario")
-def create_montura_inventario(montura_inventario: Montura_inventario):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "INSERT INTO Montura_inventario (id_montura, precio_unit, stock, codigo) VALUES (?, ?, ?, ?)",
-                (
-                    montura_inventario.id_montura,
-                    montura_inventario.precio_unit,
-                    montura_inventario.stock,
-                    montura_inventario.codigo,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Montura_inventario creada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# busqueda de montura_inventario por codigo con like, manejo de errores y clase pydantic
-class Montura_inventarioCodigo(BaseModel):
-    codigo: str
-
-
-# post/monturas_inventario/busqueda -> buscar una montura_inventario por codigo
-@app.post("/monturas_inventario/busqueda")
-def buscar_montura_inventario(montura_inventario: Montura_inventarioCodigo):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "SELECT * FROM Montura_inventario WHERE codigo LIKE ?",
-                (montura_inventario.codigo,),
-            )
-            montura_inventario = cursor.fetchall()
-            if montura_inventario:
-                return montura_inventario
-            else:
-                raise HTTPException(
-                    status_code=404, detail="Montura_inventario no encontrada"
-                )
-    except Exception as e:
-        print(e)
-        return []
-
-
-# put/monturas_inventario -> actualizar una montura_inventario con una clase pydantic
-class Montura_inventarioUpdate(BaseModel):
-    id_montura_inventario: int
-    id_montura: int
-    precio_unit: float
-    stock: int
-    codigo: str
-
-
-# metodo put de monturas_inventario con manejo de errores
-@app.put("/monturas_inventario")
-def update_montura_inventario(montura_inventario: Montura_inventarioUpdate):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "UPDATE Montura_inventario SET id_montura = ?, precio_unit = ?, stock = ?, codigo = ? WHERE id_montura_inventario = ?",
-                (
-                    montura_inventario.id_montura,
-                    montura_inventario.precio_unit,
-                    montura_inventario.stock,
-                    montura_inventario.codigo,
-                    montura_inventario.id_montura_inventario,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Montura_inventario actualizada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# delete/monturas_inventario -> eliminar una montura_inventario con una clase pydantic
-class Montura_inventarioDelete(BaseModel):
-    id_montura_inventario: int
-
-
-# metodo delete de monturas_inventario con manejo de errores
-@app.delete("/monturas_inventario")
-def delete_montura_inventario(montura_inventario: Montura_inventarioDelete):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM Montura_inventario WHERE id_montura_inventario = ?",
-                (montura_inventario.id_montura_inventario,),
-            )
-            conn.commit()
-            return {"mensaje": "Montura_inventario eliminada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-"""
-CREATE TABLE boleta (
-  id_boleta INTEGER PRIMARY KEY AUTOINCREMENT,
-  precio_total REAL,
-  estado_recojo VARCHAR
-)
-"""
-
-
-# get/boletas -> obtener todas las boletas con with connection as conn, manejo de errores
-@app.get("/boletas")
-def get_boletas():
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM boleta")
-            boletas = cursor.fetchall()
-            return boletas
-    except Exception as e:
-        print(e)
-        return []
-
-
-# get/boletas/{id_boleta} -> obtener una boleta por id
-@app.get("/boletas/{id_boleta}")
-def get_boleta(id_boleta: int):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM boleta WHERE id_boleta = ?", (id_boleta,))
-            boleta = cursor.fetchone()
-            if boleta:
-                return boleta
-            else:
-                raise HTTPException(status_code=404, detail="Boleta no encontrada")
-    except Exception as e:
-        print(e)
-        return []
-
-
-# post/boletas -> crear una boleta con una clase pydantic
-class Boleta(BaseModel):
-    precio_total: float
-    estado_recojo: str
-
-
-# metodo post de boletas con manejo de errores
-@app.post("/boletas")
-def create_boleta(boleta: Boleta):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "INSERT INTO boleta (precio_total, estado_recojo) VALUES (?, ?)",
-                (
-                    boleta.precio_total,
-                    boleta.estado_recojo,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Boleta creada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# put/boletas -> actualizar una boleta con una clase pydantic
-class BoletaUpdate(BaseModel):
-    id_boleta: int
-    precio_total: float
-    estado_recojo: str
-
-
-# metodo put de boletas con manejo de errores
-@app.put("/boletas")
-def update_boleta(boleta: BoletaUpdate):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "UPDATE boleta SET precio_total = ?, estado_recojo = ? WHERE id_boleta = ?",
-                (
-                    boleta.precio_total,
-                    boleta.estado_recojo,
-                    boleta.id_boleta,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Boleta actualizada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# delete/boletas -> eliminar una boleta con una clase pydantic
-class BoletaDelete(BaseModel):
-    id_boleta: int
-
-
-# metodo delete de boletas con manejo de errores
-@app.delete("/boletas")
-def delete_boleta(boleta: BoletaDelete):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM boleta WHERE id_boleta = ?", (boleta.id_boleta,)
-            )
-            conn.commit()
-            return {"mensaje": "Boleta eliminada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-def generar_boleta(idboleta, cliente, productos, adelanto, saldo):
-    # crear directorio si no existe en pdf/boleta
-    directorio_pdf = "pdf/boleta/"
-    os.makedirs(directorio_pdf, exist_ok=True)
-    # Crear un nombre de archivo único basado en la fecha y hora actual
-    now = datetime.now()
-    formatted_date_time = now.strftime("%Y%m%d%H%M%S")
-    nombre_archivo = f"{directorio_pdf}boleta_{formatted_date_time}.pdf"
-
-    # Inicializar el lienzo del PDF
-    c = canvas.Canvas(nombre_archivo, pagesize=letter)
-    ubicacion_inicio = 700
-    # Configurar la tipografía para la sección del cliente
-    c.setFont("Craftcoke", 30)
-    c.drawString(100, ubicacion_inicio, "Arte Visual")
-
-    # Configurar la tipografía para la sección de productos
-    c.setFont("Oregon", 12)
-    c.drawString(420, ubicacion_inicio, "NOTA DE PEDIDO")
-    # agregar numero de pedido con numero idboleta
-    c.drawString(420, ubicacion_inicio - 20, f"N° {str(idboleta).zfill(12)}")
-    c.drawString(100, ubicacion_inicio - 20, "Av. Los Héroes 632-S.J.M.")
-    # agregar logo de whatsapp de 30x30
-    c.drawImage("./img/pdf/logo_whatsapp.jpg", 100, ubicacion_inicio - 43, 12, 12)
-    c.drawString(115, ubicacion_inicio - 40, "902-501-054/ 968-600-415")
-    # añadir fecha a la derecha
-    c.drawString(420, ubicacion_inicio - 40, f"Fecha: {now.strftime('%d/%m/%Y')}")
-    # Información del cliente
-    c.drawString(
-        100, ubicacion_inicio - 60, f"Señor(a): {cliente['nombres_y_apellidos']}"
-    )
-    c.drawString(
-        100,
-        ubicacion_inicio - 80,
-        f"Dirección: {cliente['direccion']}",
-    )
-    c.drawString(
-        420,
-        ubicacion_inicio - 80,
-        f"Celular: {cliente['telefono']}",
-    )
-
-    # Configurar la tipografía para la sección de productos
-    c.setFont("Oregon", 10)
-    c.drawString(100, ubicacion_inicio - 110, "Tabla de productos:")
-
-    # Crear la tabla de productos
-    productos_data = [["Cantidad", "Descripción", "P.Unitario", "Importe"]]
-    for producto in productos:
-        productos_data.append(
-            [
-                producto["cantidad"],
-                producto["descripcion"],
-                f"S/.{producto['precio']:.2f}",
-                f"S/.{producto['importe']:.2f}",
-            ]
-        )
-
-    # Configurar el estilo de la tabla
-    style = TableStyle(
-        [
-            ("BACKGROUND", (0, 0), (-1, 0), "grey"),
-            ("TEXTCOLOR", (0, 0), (-1, 0), "white"),
-            ("ALIGN", (0, 0), (-1, -1), "CENTER"),
-            ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),  # Alineación vertical al centro
-            ("FONTNAME", (0, 0), (-1, 0), "Oregon"),
-            ("FONTNAME", (0, 1), (-1, -1), "Oregon"),
-            ("BOTTOMPADDING", (0, 0), (-1, 0), 12),
-            ("BACKGROUND", (0, 1), (-1, -1), "white"),
-            ("GRID", (0, 0), (-1, -1), 1, "grey"),
-        ]
-    )
-
-    # Crear la tabla y aplicar el estilo
-    table = Table(productos_data, colWidths=[50, 220, 80, 80])
-    table.setStyle(style)
-
-    # Dibuja el título de la tabla
-    c.drawString(100, ubicacion_inicio - 110, "Tabla de productos:")
-
-    # Calcula la altura de la tabla
-    altura_tabla = table.wrapOn(c, 400, ubicacion_inicio - 350)[1]
-
-    # Dibuja la tabla
-    table.drawOn(c, 100, ubicacion_inicio - 130 - altura_tabla)
-
-    # Ajusta la ubicación de inicio para los elementos siguientes
-    ubicacion_inicio = ubicacion_inicio - 130 - altura_tabla
-
-    # Información de pago
-    c.setFont("Oregon", 12)
-    c.drawString(100, ubicacion_inicio - 40, f"Adelanto: S/.{adelanto:.2f}")
-    c.drawString(250, ubicacion_inicio - 40, f"Saldo: S/.{saldo:.2f}")
-
-    # Calcular el total
-    total = adelanto + saldo
-    c.drawString(450, ubicacion_inicio - 40, f"Total: S/.{total:.2f}")
-
-    # Guardar y cerrar el archivo PDF
-    c.save()
-
-    print(f"Boleta generada como: {nombre_archivo}")
-    return nombre_archivo
-
-
-def obtener_datos_boleta(id_boleta, adelanto):
-    conn = DatabaseConnection().get_connection()
-    cursor = conn.cursor()
-    query = """
-            SELECT
-                Cliente.nombres_y_apellidos,
-                Cliente.direccion,
-                Cliente.telefono,
-                lunas_pedido.descripcion AS producto,
-                lunas_pedido.precio AS precio_unitario,
-                lunas_pedido.cantidad,
-                boleta.precio_total AS adelanto,
-                boleta.precio_total - COALESCE(SUM(lunas_pedido.precio * lunas_pedido.cantidad), 0) AS saldo,
-                montura_pedido.id_montura_pedido,
-                montura_pedido.cantidad AS cantidad_monturas,
-                montura_inventario.precio_unit AS precio_unitario_monturas,
-                montura.nombre_montura,
-                montura.marca,
-                montura.color,
-                montura.material
-            FROM boleta
-            JOIN lunas_pedido ON boleta.id_boleta = lunas_pedido.id_boleta
-            JOIN Prescripcion ON lunas_pedido.id_prescripcion = Prescripcion.id_prescripcion
-            JOIN Medidas ON Prescripcion.id_medidas = Medidas.id_medidas
-            JOIN Cliente ON Medidas.id_cliente = Cliente.id_cliente
-            LEFT JOIN montura_pedido ON boleta.id_boleta = montura_pedido.id_boleta
-            LEFT JOIN montura_inventario ON montura_pedido.id_montura_inventario = montura_inventario.id_montura_inventario
-            LEFT JOIN montura ON montura_inventario.id_montura = montura.id_montura
-            WHERE boleta.id_boleta = ?
-            GROUP BY boleta.id_boleta
-            """
-
-    cursor.execute(query, (id_boleta,))
-    datos = cursor.fetchone()
-
-    conn.close()
-
-    return datos
-
-
-def obtener_productos_por_boleta(id_boleta):
-    # Conectarse a la base de datos SQLite
-    conn = DatabaseConnection().get_connection()
-    cursor = conn.cursor()
-
-    # Consulta para monturas
-    query_monturas = f"""
-    SELECT
-      mp.cantidad AS cantidad,
-      mi.codigo AS codigo_montura,
-      m.nombre_montura AS nombre_montura,
-      m.marca,
-      m.color,
-      m.material,
-      mi.precio_unit AS precio_unitario,
-      (mi.precio_unit * mp.cantidad) AS importe
-    FROM
-      montura_pedido mp
-    JOIN
-      montura_inventario mi ON mp.id_montura_inventario = mi.id_montura_inventario
-    JOIN
-      montura m ON mi.id_montura = m.id_montura
-    WHERE
-      mp.id_boleta = {id_boleta};
-    """
-
-    cursor.execute(query_monturas)
-    resultados_monturas = cursor.fetchall()
-
-    # Consulta para lunas
-    query_lunas = f"""
-    SELECT
-      lp.cantidad AS cantidad,
-      p.detalle_lunas AS descripcion,
-      lp.precio AS precio,
-      (lp.precio * lp.cantidad) AS importe
-    FROM
-      lunas_pedido lp
-    JOIN
-      boleta b ON lp.id_boleta = b.id_boleta
-    JOIN
-      prescripcion p ON lp.id_prescripcion = p.id_prescripcion
-    WHERE
-      b.id_boleta = {id_boleta};
-    """
-
-    cursor.execute(query_lunas)
-    resultados_lunas = cursor.fetchall()
-    # Cerrar la conexión a la base de datos
-    conn.close()
-
-    # Crear un diccionario combinado con los resultados
-    productos = []
-    print("Esta es la cantidad de monturas y lunas:")
-    print(f"Monturas: {len(resultados_monturas)}")
-    print(f"Lunas: {len(resultados_lunas)}")
-    # validacion si hay monturas
-    if len(resultados_monturas) > 0:
-        # Agregar monturas al diccionario
-        for resultado_montura in resultados_monturas:
-            producto_montura = {
-                "cantidad": resultado_montura[0],
-                "descripcion": f"Código: {resultado_montura[1]}, \nNombre: {resultado_montura[2]}, \nMarca: {resultado_montura[3]}, \nColor: {resultado_montura[4]}, \nMaterial: {resultado_montura[5]}",
-                "precio": resultado_montura[6],
-                "importe": resultado_montura[7],
-            }
-            productos.append(producto_montura)
-    # validacion si hay lunas
-    if len(resultados_lunas) > 0:
-        # Agregar lunas al diccionario
-        for resultado_luna in resultados_lunas:
-            producto_luna = {
-                "cantidad": resultado_luna[0],
-                "descripcion": resultado_luna[1],
-                "precio": resultado_luna[2],
-                "importe": resultado_luna[3],
-            }
-            productos.append(producto_luna)
-
-    return productos
-
-
-def generar_boleta_desde_bd(id_boleta, adelanto):
-    # Obtener datos de la boleta desde la base de datos
-    datos = obtener_datos_boleta(id_boleta, adelanto)
-
-    if datos:
-        # Crear boleta usando los datos calculados
-        cliente = {
-            "nombres_y_apellidos": datos["nombres_y_apellidos"],
-            "direccion": datos["direccion"],
-            "telefono": datos["telefono"],
-        }
-        productos = obtener_productos_por_boleta(id_boleta)
-        # Calcular total y saldo
-        total = sum(
-            [producto["cantidad"] * producto["precio"] for producto in productos]
-        )
-        saldo = total - adelanto
-        # Generar la boleta
-        archivo_pdf_ok = generar_boleta(id_boleta, cliente, productos, adelanto, saldo)
-        print(archivo_pdf_ok)
-    else:
-        print(f"No se encontraron datos para la boleta con ID {id_boleta}.")
-
-
-# endpoint retorna el pdf de la boleta con idboleta y adelanto
-@app.get("/boleta/descargarPDF/{id_boleta}/{adelanto}")
-def descargar_pdf_boleta_get(id_boleta: int, adelanto: float):
-    try:
-        directorio_pdf = "pdf/boleta/"
-        now = datetime.now()
-        formatted_date_time = now.strftime("%Y%m%d%H%M%S")
-        nombre_archivo = f"{directorio_pdf}boleta_{formatted_date_time}.pdf"
-        # crear pdf
-        generar_boleta_desde_bd(id_boleta, adelanto)
-        # validacion si existe el archivo o no y retorna el archivo pdf
-        if os.path.exists(nombre_archivo):
-            # return nombre_archivo
-            return FileResponse(
-                nombre_archivo,
-                media_type="application/pdf",
-                filename=nombre_archivo,
-            )
-        else:
-            raise HTTPException(
-                status_code=404, detail="No se encontró la boleta solicitada"
-            )
-    except Exception as e:
-        print(e)
-        return []
-
-
-# crear endpoint retornando la url del PDF con los datos de la prescripción
-@app.get("/boleta/verPDF/{id_boleta}/{adelanto}")
-def ver_pdf_boleta_get(id_boleta: int, adelanto: float):
-    try:
-        directorio_pdf = "pdf/boleta/"
-        formatted_date_time = datetime.now().strftime("%Y%m%d%H%M%S")
-        nombre_archivo = f"{directorio_pdf}boleta_{formatted_date_time}.pdf"
-        generar_boleta_desde_bd(id_boleta, adelanto)
-        if os.path.exists(nombre_archivo):
-            return FileResponse(path=nombre_archivo)
-        else:
-            raise HTTPException(
-                status_code=404, detail="No se encontró la boleta solicitada"
-            )
-    except Exception as e:
-        print(e)
-        return []
-
-
-# clase boletaPDF para recibir los datos de la boleta
-class BoletaPDF(BaseModel):
-    id_boleta: int
-    adelanto: float
-
-
-# ruta para generar boleta en pdf con manejo de errores en caso no se encuentre la boleta
-@app.post("/boleta/descargarPDF")
-def descargar_boleta_pdf_post(boleta_pdf: BoletaPDF):
-    try:
-        directorio_pdf = "pdf/boleta/"
-        now = datetime.now()
-        formatted_date_time = now.strftime("%Y%m%d%H%M%S")
-        nombre_archivo = f"{directorio_pdf}boleta_{formatted_date_time}.pdf"
-        # crear pdf
-        generar_boleta_desde_bd(boleta_pdf.id_boleta, boleta_pdf.adelanto)
-        # validacion si existe el archivo o no
-        if os.path.exists(nombre_archivo):
-            return FileResponse(
-                nombre_archivo,
-                media_type="application/pdf",
-                filename=nombre_archivo,
-            )
-        else:
-            raise HTTPException(
-                status_code=404, detail="No se encontró la boleta solicitada"
-            )
-    except Exception as e:
-        print(e)
-        return []
-
-
-# get obtiene la ultima boleta creada
-@app.get("/boleta/ultima")
-def get_ultima_boleta():
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM boleta ORDER BY id_boleta DESC LIMIT 1")
-            boleta = cursor.fetchone()
-            return boleta
-    except Exception as e:
-        print(e)
-        return []
-
-
-"""
-CREATE TABLE montura_pedido (
-  id_montura_pedido INTEGER PRIMARY KEY AUTOINCREMENT,
-  id_montura_inventario INTEGER REFERENCES Montura_inventario(id_montura_inventario),
-  cantidad INTEGER,
-  precio REAL,
-  id_boleta INTEGER REFERENCES boleta(id_boleta)
-)
-"""
-
-
-# get/monturas_pedidos -> obtener todas las monturas_pedidos con with connection as conn, manejo de errores
-@app.get("/monturas_pedidos")
-def get_monturas_pedidos():
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM montura_pedido")
-            monturas_pedidos = cursor.fetchall()
-            return monturas_pedidos
-    except Exception as e:
-        print(e)
-        return []
-
-
-# get/monturas_pedidos/{id_montura_pedido} -> obtener una montura_pedido por id
-@app.get("/monturas_pedidos/{id_montura_pedido}")
-def get_montura_pedido(id_montura_pedido: int):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "SELECT * FROM montura_pedido WHERE id_montura_pedido = ?",
-                (id_montura_pedido,),
-            )
-            montura_pedido = cursor.fetchone()
-            return montura_pedido
-    except Exception as e:
-        print(e)
-        return []
-
-
-# post/monturas_pedidos -> crear una montura_pedido con una clase pydantic
-class Montura_pedido(BaseModel):
-    id_montura_inventario: int
-    cantidad: int
-    precio: float
-    id_boleta: int
-
-
-# metodo post de monturas_pedidos con manejo de errores
-@app.post("/monturas_pedidos")
-def create_montura_pedido(montura_pedido: Montura_pedido):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "INSERT INTO montura_pedido (id_montura_inventario, cantidad, precio, id_boleta) VALUES (?, ?, ?, ?)",
-                (
-                    montura_pedido.id_montura_inventario,
-                    montura_pedido.cantidad,
-                    montura_pedido.precio,
-                    montura_pedido.id_boleta,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Montura_pedido creada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# put/monturas_pedidos -> actualizar una montura_pedido con una clase pydantic
-class Montura_pedidoUpdate(BaseModel):
-    id_montura_pedido: int
-    id_montura_inventario: int
-    cantidad: int
-    precio: float
-    id_boleta: int
-
-
-# metodo put de monturas_pedidos con manejo de errores
-@app.put("/monturas_pedidos")
-def update_montura_pedido(montura_pedido: Montura_pedidoUpdate):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "UPDATE montura_pedido SET id_montura_inventario = ?, cantidad = ?, precio = ?, id_boleta = ? WHERE id_montura_pedido = ?",
-                (
-                    montura_pedido.id_montura_inventario,
-                    montura_pedido.cantidad,
-                    montura_pedido.precio,
-                    montura_pedido.id_boleta,
-                    montura_pedido.id_montura_pedido,
-                ),
-            )
-            conn.commit()
-            return {"mensaje": "Montura_pedido actualizada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
-
-
-# delete/monturas_pedidos -> eliminar una montura_pedido con una clase pydantic
-class Montura_pedidoDelete(BaseModel):
-    id_montura_pedido: int
-
-
-# metodo delete de monturas_pedidos con manejo de errores
-@app.delete("/monturas_pedidos")
-def delete_montura_pedido(montura_pedido: Montura_pedidoDelete):
-    try:
-        with DatabaseConnection().get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                "DELETE FROM montura_pedido WHERE id_montura_pedido = ?",
-                (montura_pedido.id_montura_pedido,),
-            )
-            conn.commit()
-            return {"mensaje": "Montura_pedido eliminada exitosamente"}
-    except Exception as e:
-        print(e)
-        return []
+if __name__ == "__main__":
+    os.system('uvicorn app:app --host "localhost" --port 7860 --reload')

database/conexion.py

@@ -0,0 +1,46 @@
+from library.librerias import sqlite3, Queue, threading
+
+
+class DatabaseConnection:
+    """
+    Clase para gestionar las conexiones a la base de datos con un pool.
+    """
+
+    _instance = None
+    _lock = threading.Lock()
+    _connection_pool = Queue(maxsize=5)
+
+    def __new__(cls):
+        """
+        Crea una nueva instancia de la clase si no existe.
+        """
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+                cls._instance.conn = cls._instance._create_connection()
+        return cls._instance
+
+    def _create_connection(self):
+        """
+        Crea una conexión a la base de datos.
+        """
+        if not self._connection_pool.empty():
+            return self._connection_pool.get()
+        else:
+            connection = sqlite3.connect("database/opticaDB.db")
+            connection.row_factory = sqlite3.Row
+            return connection
+
+    def get_connection(self):
+        """
+        Obtener el objeto de conexión de la base de datos.
+        """
+        return self._instance._create_connection()
+
+    def release_connection(self):
+        """
+        Liberar la conexión de nuevo al pool.
+        """
+        if self._instance is not None:
+            self._connection_pool.put(self._instance.conn)
+            self._instance.conn = None  # Marcar la instancia como sin conexión

library/librerias.py

@@ -0,0 +1,28 @@
+# librerias propias del lenguaje
+from datetime import datetime
+from datetime import date
+import os
+
+# librerias para la API
+from pydantic import BaseModel
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi import APIRouter, Depends, status
+import uvicorn
+
+# librerias para el pdf
+from reportlab.pdfgen import canvas
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfbase import pdfmetrics
+from reportlab.pdfbase.ttfonts import TTFont
+from reportlab.platypus import Table, TableStyle
+
+# importar librerias para la conexion a la base de datos
+from queue import Queue
+import sqlite3
+import threading
+
+
+# clase para la conexion a la base de datos
+from database.conexion import DatabaseConnection

routers/boletas.py

@@ -0,0 +1,122 @@
+from library.librerias import *
+
+router = APIRouter(
+    prefix="/boletas",
+    tags=["Boletas"],
+    responses={404: {"description": "No encontrado"}},
+)
+
+
+"""
+CREATE TABLE boleta (
+  id_boleta INTEGER PRIMARY KEY AUTOINCREMENT,
+  precio_total REAL,
+  estado_recojo VARCHAR
+)
+"""
+
+
+# get/boletas -> obtener todas las boletas con with connection as conn, manejo de errores
+@router.get("/")
+def get_boletas():
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM boleta")
+            boletas = cursor.fetchall()
+            return boletas
+    except Exception as e:
+        print(e)
+        return []
+
+
+# get/boletas/{id_boleta} -> obtener una boleta por id
+@router.get("/{id_boleta}")
+def get_boleta(id_boleta: int):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM boleta WHERE id_boleta = ?", (id_boleta,))
+            boleta = cursor.fetchone()
+            if boleta:
+                return boleta
+            else:
+                raise HTTPException(status_code=404, detail="Boleta no encontrada")
+    except Exception as e:
+        print(e)
+        return []
+
+
+# post/boletas -> crear una boleta con una clase pydantic
+class Boleta(BaseModel):
+    precio_total: float
+    estado_recojo: str
+
+
+# metodo post de boletas con manejo de errores
+@router.post("/")
+def create_boleta(boleta: Boleta):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO boleta (precio_total, estado_recojo) VALUES (?, ?)",
+                (
+                    boleta.precio_total,
+                    boleta.estado_recojo,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Boleta creada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# put/boletas -> actualizar una boleta con una clase pydantic
+class BoletaUpdate(BaseModel):
+    id_boleta: int
+    precio_total: float
+    estado_recojo: str
+
+
+# metodo put de boletas con manejo de errores
+@router.put("/")
+def update_boleta(boleta: BoletaUpdate):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE boleta SET precio_total = ?, estado_recojo = ? WHERE id_boleta = ?",
+                (
+                    boleta.precio_total,
+                    boleta.estado_recojo,
+                    boleta.id_boleta,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Boleta actualizada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# delete/boletas -> eliminar una boleta con una clase pydantic
+class BoletaDelete(BaseModel):
+    id_boleta: int
+
+
+# metodo delete de boletas con manejo de errores
+@router.delete("/")
+def delete_boleta(boleta: BoletaDelete):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "DELETE FROM boleta WHERE id_boleta = ?", (boleta.id_boleta,)
+            )
+            conn.commit()
+            return {"mensaje": "Boleta eliminada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []

routers/clientes.py

@@ -0,0 +1,188 @@
+from library.librerias import *
+
+router = APIRouter(
+    prefix="/clientes",
+    tags=["Clientes"],
+    responses={404: {"description": "No encontrado"}},
+)
+
+
+"""
+CREATE TABLE Cliente (
+  id_cliente INTEGER PRIMARY KEY AUTOINCREMENT,
+  nombres_y_apellidos VARCHAR,
+  edad INTEGER,
+  telefono INTEGER,
+  direccion VARCHAR
+)
+"""
+
+
+# get/clientes -> obtener todos los clientes con with connection as conn, manejo de errores
+@router.get("/")
+def get_clientes():
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM Cliente")
+            clientes = cursor.fetchall()
+            return clientes
+    except Exception as e:
+        print(e)
+        return []
+
+
+@router.get("/{id_cliente}")
+def get_cliente(id_cliente: int):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM Cliente WHERE id_cliente = ?", (id_cliente,))
+            cliente = cursor.fetchone()
+            return cliente
+    except Exception as e:
+        print(e)
+        return []
+
+
+# metodo de busqueda de cliente por nombre con like, manejo de errores y clase pydantic
+class ClienteNombre(BaseModel):
+    nombres_y_apellidos: str
+
+
+@router.post("/busqueda")
+def post_cliente_busqueda(cliente: ClienteNombre):
+    try:
+        conn = DatabaseConnection().get_connection()
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT * FROM Cliente WHERE nombres_y_apellidos LIKE ?",
+            ["%" + cliente.nombres_y_apellidos + "%"],
+        )
+        cliente = cursor.fetchall()
+        if cliente:
+            return cliente
+        else:
+            raise HTTPException(status_code=404, detail="Cliente no encontrado")
+    except Exception as e:
+        print(e)
+        return []
+
+
+# post/clientes -> crear un cliente con una clase pydantic
+class Cliente(BaseModel):
+    nombres_y_apellidos: str
+    edad: int
+    telefono: int
+    direccion: str
+
+
+@router.post("/")
+def create_cliente(cliente: Cliente):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO Cliente (nombres_y_apellidos, edad, telefono, direccion) VALUES (?, ?, ?, ?)",
+                (
+                    cliente.nombres_y_apellidos,
+                    cliente.edad,
+                    cliente.telefono,
+                    cliente.direccion,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Cliente creado exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# put/clientes -> actualizar un cliente con una clase pydantic
+class ClienteUpdate(BaseModel):
+    id_cliente: int
+    nombres_y_apellidos: str
+    edad: int
+    telefono: int
+    direccion: str
+
+
+@router.put("/")
+def update_cliente(cliente: ClienteUpdate):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE Cliente SET nombres_y_apellidos = ?, edad = ?, telefono = ?, direccion = ? WHERE id_cliente = ?",
+                (
+                    cliente.nombres_y_apellidos,
+                    cliente.edad,
+                    cliente.telefono,
+                    cliente.direccion,
+                    cliente.id_cliente,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Cliente actualizado exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# delete/clientes -> eliminar un cliente con una clase pydantic
+class ClienteDelete(BaseModel):
+    id_cliente: int
+
+
+# delete/clientes -> eliminar un cliente con una clase pydantic
+@router.delete("/")
+def delete_cliente(cliente: ClienteDelete):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "DELETE FROM Cliente WHERE id_cliente = ?", (cliente.id_cliente,)
+            )
+            conn.commit()
+            return {"mensaje": "Cliente eliminado exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# Define tu clase Pydantic para el modelo de datos
+class PrescripcionId(BaseModel):
+    id_prescripcion: int
+
+
+# Define tu método de búsqueda de cliente por id de prescripción con manejo de errores y clase Pydantic
+@router.post("/prescripcion")
+def get_cliente_por_prescripcion(prescripcion_id: PrescripcionId):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            # Consulta SQL para obtener el cliente a partir del id de la prescripción
+            cursor.execute(
+                """
+                SELECT c.* 
+                FROM Cliente c
+                JOIN Medidas m ON c.id_cliente = m.id_cliente
+                JOIN Prescripcion p ON m.id_medidas = p.id_medidas
+                WHERE p.id_prescripcion = ?
+                """,
+                [prescripcion_id.id_prescripcion],
+            )
+
+            cliente = cursor.fetchone()
+
+            if cliente:
+                return cliente
+            else:
+                raise HTTPException(
+                    status_code=404,
+                    detail="Cliente no encontrado para la prescripción proporcionada",
+                )
+
+    except Exception as e:
+        print(e)
+        return []

routers/comprobante_pago.py

@@ -0,0 +1,355 @@
+from library.librerias import *
+
+router = APIRouter(
+    prefix="/comprobante_pago",
+    tags=["Comprobante Pago"],
+    responses={404: {"description": "No encontrado"}},
+)
+
+# Cargar varias tipografías
+pdfmetrics.registerFont(TTFont("Craftcoke", "./font/Craftcoke.ttf"))
+pdfmetrics.registerFont(TTFont("Oregon", "./font/Oregon.ttf"))
+pdfmetrics.registerFont(TTFont("Roboto", "./font/Roboto.ttf"))
+
+
+def generar_boleta(idboleta, cliente, productos, adelanto, saldo):
+    # crear directorio si no existe en pdf/boleta
+    directorio_pdf = "pdf/boleta/"
+    os.makedirs(directorio_pdf, exist_ok=True)
+    # Crear un nombre de archivo único basado en la fecha y hora actual
+    now = datetime.now()
+    formatted_date_time = now.strftime("%Y%m%d%H%M%S")
+    nombre_archivo = f"{directorio_pdf}boleta_{formatted_date_time}.pdf"
+
+    # Inicializar el lienzo del PDF
+    c = canvas.Canvas(nombre_archivo, pagesize=letter)
+    ubicacion_inicio = 700
+    # Configurar la tipografía para la sección del cliente
+    c.setFont("Craftcoke", 30)
+    c.drawString(100, ubicacion_inicio, "Arte Visual")
+
+    # Configurar la tipografía para la sección de productos
+    c.setFont("Oregon", 12)
+    c.drawString(420, ubicacion_inicio, "NOTA DE PEDIDO")
+    # agregar numero de pedido con numero idboleta
+    c.drawString(420, ubicacion_inicio - 20, f"N° {str(idboleta).zfill(12)}")
+    c.drawString(100, ubicacion_inicio - 20, "Av. Los Héroes 632-S.J.M.")
+    # agregar logo de whatsapp de 30x30
+    c.drawImage("./img/pdf/logo_whatsapp.jpg", 100, ubicacion_inicio - 43, 12, 12)
+    c.drawString(115, ubicacion_inicio - 40, "902-501-054/ 968-600-415")
+    # añadir fecha a la derecha
+    c.drawString(420, ubicacion_inicio - 40, f"Fecha: {now.strftime('%d/%m/%Y')}")
+    # Información del cliente
+    c.drawString(
+        100, ubicacion_inicio - 60, f"Señor(a): {cliente['nombres_y_apellidos']}"
+    )
+    c.drawString(
+        100,
+        ubicacion_inicio - 80,
+        f"Dirección: {cliente['direccion']}",
+    )
+    c.drawString(
+        420,
+        ubicacion_inicio - 80,
+        f"Celular: {cliente['telefono']}",
+    )
+
+    # Configurar la tipografía para la sección de productos
+    c.setFont("Oregon", 10)
+    c.drawString(100, ubicacion_inicio - 110, "Tabla de productos:")
+
+    # Crear la tabla de productos
+    productos_data = [["Cantidad", "Descripción", "P.Unitario", "Importe"]]
+    for producto in productos:
+        productos_data.append(
+            [
+                producto["cantidad"],
+                producto["descripcion"],
+                f"S/.{producto['precio']:.2f}",
+                f"S/.{producto['importe']:.2f}",
+            ]
+        )
+
+    # Configurar el estilo de la tabla
+    style = TableStyle(
+        [
+            ("BACKGROUND", (0, 0), (-1, 0), "grey"),
+            ("TEXTCOLOR", (0, 0), (-1, 0), "white"),
+            ("ALIGN", (0, 0), (-1, -1), "CENTER"),
+            ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),  # Alineación vertical al centro
+            ("FONTNAME", (0, 0), (-1, 0), "Oregon"),
+            ("FONTNAME", (0, 1), (-1, -1), "Oregon"),
+            ("BOTTOMPADDING", (0, 0), (-1, 0), 12),
+            ("BACKGROUND", (0, 1), (-1, -1), "white"),
+            ("GRID", (0, 0), (-1, -1), 1, "grey"),
+        ]
+    )
+
+    # Crear la tabla y aplicar el estilo
+    table = Table(productos_data, colWidths=[50, 220, 80, 80])
+    table.setStyle(style)
+
+    # Dibuja el título de la tabla
+    c.drawString(100, ubicacion_inicio - 110, "Tabla de productos:")
+
+    # Calcula la altura de la tabla
+    altura_tabla = table.wrapOn(c, 400, ubicacion_inicio - 350)[1]
+
+    # Dibuja la tabla
+    table.drawOn(c, 100, ubicacion_inicio - 130 - altura_tabla)
+
+    # Ajusta la ubicación de inicio para los elementos siguientes
+    ubicacion_inicio = ubicacion_inicio - 130 - altura_tabla
+
+    # Información de pago
+    c.setFont("Oregon", 12)
+    c.drawString(100, ubicacion_inicio - 40, f"Adelanto: S/.{adelanto:.2f}")
+    c.drawString(250, ubicacion_inicio - 40, f"Saldo: S/.{saldo:.2f}")
+
+    # Calcular el total
+    total = adelanto + saldo
+    c.drawString(450, ubicacion_inicio - 40, f"Total: S/.{total:.2f}")
+
+    # Guardar y cerrar el archivo PDF
+    c.save()
+
+    print(f"Boleta generada como: {nombre_archivo}")
+    return nombre_archivo
+
+
+def obtener_datos_boleta(id_boleta, adelanto):
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+    query = """
+            SELECT
+                Cliente.nombres_y_apellidos,
+                Cliente.direccion,
+                Cliente.telefono,
+                lunas_pedido.descripcion AS producto,
+                lunas_pedido.precio AS precio_unitario,
+                lunas_pedido.cantidad,
+                boleta.precio_total AS adelanto,
+                boleta.precio_total - COALESCE(SUM(lunas_pedido.precio * lunas_pedido.cantidad), 0) AS saldo,
+                montura_pedido.id_montura_pedido,
+                montura_pedido.cantidad AS cantidad_monturas,
+                montura_inventario.precio_unit AS precio_unitario_monturas,
+                montura.nombre_montura,
+                montura.marca,
+                montura.color,
+                montura.material
+            FROM boleta
+            JOIN lunas_pedido ON boleta.id_boleta = lunas_pedido.id_boleta
+            JOIN Prescripcion ON lunas_pedido.id_prescripcion = Prescripcion.id_prescripcion
+            JOIN Medidas ON Prescripcion.id_medidas = Medidas.id_medidas
+            JOIN Cliente ON Medidas.id_cliente = Cliente.id_cliente
+            LEFT JOIN montura_pedido ON boleta.id_boleta = montura_pedido.id_boleta
+            LEFT JOIN montura_inventario ON montura_pedido.id_montura_inventario = montura_inventario.id_montura_inventario
+            LEFT JOIN montura ON montura_inventario.id_montura = montura.id_montura
+            WHERE boleta.id_boleta = ?
+            GROUP BY boleta.id_boleta
+            """
+
+    cursor.execute(query, (id_boleta,))
+    datos = cursor.fetchone()
+
+    conn.close()
+
+    return datos
+
+
+def obtener_productos_por_boleta(id_boleta):
+    # Conectarse a la base de datos SQLite
+    conn = DatabaseConnection().get_connection()
+    cursor = conn.cursor()
+
+    # Consulta para monturas
+    query_monturas = f"""
+    SELECT
+      mp.cantidad AS cantidad,
+      mi.codigo AS codigo_montura,
+      m.nombre_montura AS nombre_montura,
+      m.marca,
+      m.color,
+      m.material,
+      mi.precio_unit AS precio_unitario,
+      (mi.precio_unit * mp.cantidad) AS importe
+    FROM
+      montura_pedido mp
+    JOIN
+      montura_inventario mi ON mp.id_montura_inventario = mi.id_montura_inventario
+    JOIN
+      montura m ON mi.id_montura = m.id_montura
+    WHERE
+      mp.id_boleta = {id_boleta};
+    """
+
+    cursor.execute(query_monturas)
+    resultados_monturas = cursor.fetchall()
+
+    # Consulta para lunas
+    query_lunas = f"""
+    SELECT
+      lp.cantidad AS cantidad,
+      p.detalle_lunas AS descripcion,
+      lp.precio AS precio,
+      (lp.precio * lp.cantidad) AS importe
+    FROM
+      lunas_pedido lp
+    JOIN
+      boleta b ON lp.id_boleta = b.id_boleta
+    JOIN
+      prescripcion p ON lp.id_prescripcion = p.id_prescripcion
+    WHERE
+      b.id_boleta = {id_boleta};
+    """
+
+    cursor.execute(query_lunas)
+    resultados_lunas = cursor.fetchall()
+    # Cerrar la conexión a la base de datos
+    conn.close()
+
+    # Crear un diccionario combinado con los resultados
+    productos = []
+    print("Esta es la cantidad de monturas y lunas:")
+    print(f"Monturas: {len(resultados_monturas)}")
+    print(f"Lunas: {len(resultados_lunas)}")
+    # validacion si hay monturas
+    if len(resultados_monturas) > 0:
+        # Agregar monturas al diccionario
+        for resultado_montura in resultados_monturas:
+            producto_montura = {
+                "cantidad": resultado_montura[0],
+                "descripcion": f"Código: {resultado_montura[1]}, \nNombre: {resultado_montura[2]}, \nMarca: {resultado_montura[3]}, \nColor: {resultado_montura[4]}, \nMaterial: {resultado_montura[5]}",
+                "precio": resultado_montura[6],
+                "importe": resultado_montura[7],
+            }
+            productos.append(producto_montura)
+    # validacion si hay lunas
+    if len(resultados_lunas) > 0:
+        # Agregar lunas al diccionario
+        for resultado_luna in resultados_lunas:
+            producto_luna = {
+                "cantidad": resultado_luna[0],
+                "descripcion": resultado_luna[1],
+                "precio": resultado_luna[2],
+                "importe": resultado_luna[3],
+            }
+            productos.append(producto_luna)
+
+    return productos
+
+
+def generar_boleta_desde_bd(id_boleta, adelanto):
+    # Obtener datos de la boleta desde la base de datos
+    datos = obtener_datos_boleta(id_boleta, adelanto)
+
+    if datos:
+        # Crear boleta usando los datos calculados
+        cliente = {
+            "nombres_y_apellidos": datos["nombres_y_apellidos"],
+            "direccion": datos["direccion"],
+            "telefono": datos["telefono"],
+        }
+        productos = obtener_productos_por_boleta(id_boleta)
+        # Calcular total y saldo
+        total = sum(
+            [producto["cantidad"] * producto["precio"] for producto in productos]
+        )
+        saldo = total - adelanto
+        # Generar la boleta
+        archivo_pdf_ok = generar_boleta(id_boleta, cliente, productos, adelanto, saldo)
+        print(archivo_pdf_ok)
+    else:
+        print(f"No se encontraron datos para la boleta con ID {id_boleta}.")
+
+
+# endpoint retorna el pdf de la boleta con idboleta y adelanto
+@router.get("/descargarPDF/{id_boleta}/{adelanto}")
+def descargar_pdf_boleta_get(id_boleta: int, adelanto: float):
+    try:
+        directorio_pdf = "pdf/boleta/"
+        now = datetime.now()
+        formatted_date_time = now.strftime("%Y%m%d%H%M%S")
+        nombre_archivo = f"{directorio_pdf}boleta_{formatted_date_time}.pdf"
+        # crear pdf
+        generar_boleta_desde_bd(id_boleta, adelanto)
+        # validacion si existe el archivo o no y retorna el archivo pdf
+        if os.path.exists(nombre_archivo):
+            # return nombre_archivo
+            return FileResponse(
+                nombre_archivo,
+                media_type="application/pdf",
+                filename=nombre_archivo,
+            )
+        else:
+            raise HTTPException(
+                status_code=404, detail="No se encontró la boleta solicitada"
+            )
+    except Exception as e:
+        print(e)
+        return []
+
+
+# crear endpoint retornando la url del PDF con los datos de la prescripción
+@router.get("/verPDF/{id_boleta}/{adelanto}")
+def ver_pdf_boleta_get(id_boleta: int, adelanto: float):
+    try:
+        directorio_pdf = "pdf/boleta/"
+        formatted_date_time = datetime.now().strftime("%Y%m%d%H%M%S")
+        nombre_archivo = f"{directorio_pdf}boleta_{formatted_date_time}.pdf"
+        generar_boleta_desde_bd(id_boleta, adelanto)
+        if os.path.exists(nombre_archivo):
+            return FileResponse(path=nombre_archivo)
+        else:
+            raise HTTPException(
+                status_code=404, detail="No se encontró la boleta solicitada"
+            )
+    except Exception as e:
+        print(e)
+        return []
+
+
+# clase boletaPDF para recibir los datos de la boleta
+class BoletaPDF(BaseModel):
+    id_boleta: int
+    adelanto: float
+
+
+# ruta para generar boleta en pdf con manejo de errores en caso no se encuentre la boleta
+@router.post("/descargarPDF")
+def descargar_boleta_pdf_post(boleta_pdf: BoletaPDF):
+    try:
+        directorio_pdf = "pdf/boleta/"
+        now = datetime.now()
+        formatted_date_time = now.strftime("%Y%m%d%H%M%S")
+        nombre_archivo = f"{directorio_pdf}boleta_{formatted_date_time}.pdf"
+        # crear pdf
+        generar_boleta_desde_bd(boleta_pdf.id_boleta, boleta_pdf.adelanto)
+        # validacion si existe el archivo o no
+        if os.path.exists(nombre_archivo):
+            return FileResponse(
+                nombre_archivo,
+                media_type="application/pdf",
+                filename=nombre_archivo,
+            )
+        else:
+            raise HTTPException(
+                status_code=404, detail="No se encontró la boleta solicitada"
+            )
+    except Exception as e:
+        print(e)
+        return []
+
+
+# get obtiene la ultima boleta creada
+@router.get("/ultima")
+def get_ultima_boleta():
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM boleta ORDER BY id_boleta DESC LIMIT 1")
+            boleta = cursor.fetchone()
+            return boleta
+    except Exception as e:
+        print(e)
+        return []

routers/lunas_pedido.py

@@ -0,0 +1,118 @@
+from library.librerias import *
+
+router = APIRouter(
+    prefix="/lunas_pedido",
+    tags=["Lunas Pedido"],
+    responses={404: {"description": "No encontrado"}},
+)
+
+
+"""
+Table lunas_pedido {
+  id_lunas_pedido INTEGER [primary key, unique, increment]
+  id_prescripcion INTEGER [ref: > Prescripcion.id_prescripcion]
+  precio REAL
+  id_boleta INTEGER [ref: > boleta.id_boleta]
+  descripcion VARCHAR
+  cantidad INTEGER
+}
+"""
+
+
+# get
+@router.get("/")
+def get_lunas_pedido():
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM lunas_pedido")
+            lunas_pedido = cursor.fetchall()
+            return lunas_pedido
+    except Exception as e:
+        print(e)
+        return []
+
+
+# post con pydantic
+class LunasPedido(BaseModel):
+    id_prescripcion: int
+    precio: float
+    id_boleta: int
+    descripcion: str
+    cantidad: int
+
+
+@router.post("/")
+def create_lunas_pedido(lunas_pedido: LunasPedido):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO lunas_pedido (id_prescripcion, precio, id_boleta, descripcion, cantidad) VALUES (?, ?, ?, ?, ?)",
+                (
+                    lunas_pedido.id_prescripcion,
+                    lunas_pedido.precio,
+                    lunas_pedido.id_boleta,
+                    lunas_pedido.descripcion,
+                    lunas_pedido.cantidad,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Lunas_pedido creada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# put con pydantic
+class LunasPedidoUpdate(BaseModel):
+    id_lunas_pedido: int
+    id_prescripcion: int
+    precio: float
+    id_boleta: int
+    descripcion: str
+    cantidad: int
+
+
+@router.put("/")
+def update_lunas_pedido(lunas_pedido: LunasPedidoUpdate):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE lunas_pedido SET id_prescripcion = ?, precio = ?, id_boleta = ?, descripcion = ?, cantidad = ? WHERE id_lunas_pedido = ?",
+                (
+                    lunas_pedido.id_prescripcion,
+                    lunas_pedido.precio,
+                    lunas_pedido.id_boleta,
+                    lunas_pedido.descripcion,
+                    lunas_pedido.cantidad,
+                    lunas_pedido.id_lunas_pedido,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Lunas_pedido actualizada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# delete con pydantic
+class LunasPedidoDelete(BaseModel):
+    id_lunas_pedido: int
+
+
+@router.delete("/")
+def delete_lunas_pedido(lunas_pedido: LunasPedidoDelete):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "DELETE FROM lunas_pedido WHERE id_lunas_pedido = ?",
+                (lunas_pedido.id_lunas_pedido,),
+            )
+            conn.commit()
+            return {"mensaje": "Lunas_pedido eliminada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []

routers/medidas.py

@@ -0,0 +1,217 @@
+from library.librerias import *
+
+router = APIRouter(
+    prefix="/medidas",
+    tags=["Medidas"],
+    responses={404: {"description": "No encontrado"}},
+)
+
+
+"""
+CREATE TABLE Medidas (
+  id_medidas INTEGER PRIMARY KEY AUTOINCREMENT,
+  Esfera_OD_lejos REAL,
+  Cilindro_OD_lejos REAL,
+  Eje_OD_lejos REAL,
+  Agudeza_visual_OD_lejos REAL,
+  Esfera_OI_lejos REAL,
+  Cilindro_OI_lejos REAL,
+  Eje_OI_lejos REAL,
+  Agudeza_visual_OI_lejos REAL,
+  Esfera_OD_cerca REAL,
+  Cilindro_OD_cerca REAL,
+  Eje_OD_cerca REAL,
+  Agudeza_visual_OD_cerca REAL,
+  Esfera_OI_cerca REAL,
+  Cilindro_OI_cerca REAL,
+  Eje_OI_cerca REAL,
+  Agudeza_visual_OI_cerca REAL,
+  id_cliente INTEGER REFERENCES Cliente(id_cliente)
+)
+"""
+
+
+# get/medidas -> obtener todas las medidas con with connection as conn, manejo de errores
+@router.get("/")
+def get_medidas():
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM Medidas")
+            medidas = cursor.fetchall()
+            return medidas
+    except Exception as e:
+        print(e)
+        return []
+
+
+# get/medidas/{id_medidas} -> obtener una medida por id
+@router.get("/{id_medidas}")
+def get_medida(id_medidas: int):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM Medidas WHERE id_medidas = ?", (id_medidas,))
+            medida = cursor.fetchone()
+            return medida
+    except Exception as e:
+        print(e)
+        return []
+
+
+# metodo de busqueda que sea por id_cliente y retorne las medidas asociadas a ese cliente con clase y metodo post
+class MedidasCliente(BaseModel):
+    id_cliente: int
+
+
+@router.post("/busqueda")
+def buscar_medida(medida: MedidasCliente):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM Medidas WHERE id_cliente = ?",
+                (medida.id_cliente,),
+            )
+            medida = cursor.fetchall()
+            if medida:
+                return medida
+            else:
+                raise HTTPException(status_code=404, detail="Medida no encontrada")
+    except Exception as e:
+        print(e)
+        return []
+
+
+# post/medidas -> crear una medida con una clase pydantic
+class Medida(BaseModel):
+    Esfera_OD_lejos: float
+    Cilindro_OD_lejos: float
+    Eje_OD_lejos: float
+    Agudeza_visual_OD_lejos: float
+    Esfera_OI_lejos: float
+    Cilindro_OI_lejos: float
+    Eje_OI_lejos: float
+    Agudeza_visual_OI_lejos: float
+    Esfera_OD_cerca: float
+    Cilindro_OD_cerca: float
+    Eje_OD_cerca: float
+    Agudeza_visual_OD_cerca: float
+    Esfera_OI_cerca: float
+    Cilindro_OI_cerca: float
+    Eje_OI_cerca: float
+    Agudeza_visual_OI_cerca: float
+    id_cliente: int
+
+
+@router.post("/")
+def create_medida(medida: Medida):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            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, id_cliente) 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,
+                    medida.id_cliente,
+                ],
+            )
+            conn.commit()
+            return {"mensaje": "Medida creada correctamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# put/medidas -> actualizar una medida con una clase pydantic
+class MedidaUpdate(BaseModel):
+    id_medidas: int
+    Esfera_OD_lejos: float
+    Cilindro_OD_lejos: float
+    Eje_OD_lejos: float
+    Agudeza_visual_OD_lejos: float
+    Esfera_OI_lejos: float
+    Cilindro_OI_lejos: float
+    Eje_OI_lejos: float
+    Agudeza_visual_OI_lejos: float
+    Esfera_OD_cerca: float
+    Cilindro_OD_cerca: float
+    Eje_OD_cerca: float
+    Agudeza_visual_OD_cerca: float
+    Esfera_OI_cerca: float
+    Cilindro_OI_cerca: float
+    Eje_OI_cerca: float
+    Agudeza_visual_OI_cerca: float
+    id_cliente: int
+
+
+# metodo put de medidas con manejo de errores
+@router.put("/")
+def update_medida(medida: MedidaUpdate):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            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 = ?, id_cliente = ? WHERE id_medidas = ?",
+                [
+                    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,
+                    medida.id_cliente,
+                    medida.id_medidas,
+                ],
+            )
+            conn.commit()
+            return {"mensaje": "Medida actualizada correctamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# delete/medidas -> eliminar una medida con una clase pydantic
+class MedidaDelete(BaseModel):
+    id_medidas: int
+
+
+# metodo delete de medidas con manejo de errores
+@router.delete("/")
+def delete_medida(medida: MedidaDelete):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "DELETE FROM Medidas WHERE id_medidas = ?", (medida.id_medidas,)
+            )
+            conn.commit()
+            return {"mensaje": "Medida eliminada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []

routers/monturas.py

@@ -0,0 +1,158 @@
+from library.librerias import *
+
+router = APIRouter(
+    prefix="/monturas",
+    tags=["Monturas"],
+    responses={404: {"description": "No encontrado"}},
+)
+
+"""
+CREATE TABLE Montura (
+  id_montura INTEGER PRIMARY KEY AUTOINCREMENT,
+  nombre_montura VARCHAR,
+  imagen VARCHAR,
+  marca VARCHAR,
+  color VARCHAR,
+  material VARCHAR
+)
+"""
+
+
+# get/monturas -> obtener todas las monturas con with connection as conn, manejo de errores
+@router.get("/")
+def get_monturas():
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM Montura")
+            monturas = cursor.fetchall()
+            return monturas
+    except Exception as e:
+        print(e)
+        return []
+
+
+# get/monturas/{id_montura} -> obtener una montura por id
+@router.get("/{id_montura}")
+def get_montura(id_montura: int):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM Montura WHERE id_montura = ?", (id_montura,))
+            montura = cursor.fetchone()
+            return montura
+    except Exception as e:
+        print(e)
+        return []
+
+
+# busqueda de montura por nombre con like, manejo de errores y clase pydantic
+class MonturaNombre(BaseModel):
+    nombre_montura: str
+
+
+# post/monturas/busqueda -> buscar montura por nombre
+@router.post("/busqueda")
+def buscar_montura(montura: MonturaNombre):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM Montura WHERE nombre_montura LIKE ?",
+                (montura.nombre_montura,),
+            )
+            montura = cursor.fetchall()
+            if montura:
+                return montura
+            else:
+                raise HTTPException(status_code=404, detail="Montura no encontrada")
+    except Exception as e:
+        print(e)
+        return []
+
+
+# post/monturas -> crear una montura con una clase pydantic
+class Montura(BaseModel):
+    nombre_montura: str
+    imagen: str
+    marca: str
+    color: str
+    material: str
+
+
+# metodo post de monturas con manejo de errores
+@router.post("/")
+def create_montura(montura: Montura):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO Montura (nombre_montura, imagen, marca, color, material) VALUES (?, ?, ?, ?, ?)",
+                (
+                    montura.nombre_montura,
+                    montura.imagen,
+                    montura.marca,
+                    montura.color,
+                    montura.material,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Montura creada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# put/monturas -> actualizar una montura con una clase pydantic
+class MonturaUpdate(BaseModel):
+    id_montura: int
+    nombre_montura: str
+    imagen: str
+    marca: str
+    color: str
+    material: str
+
+
+# metodo put de monturas con manejo de errores
+@router.put("/")
+def update_montura(montura: MonturaUpdate):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE Montura SET nombre_montura = ?, imagen = ?, marca = ?, color = ?, material = ? WHERE id_montura = ?",
+                (
+                    montura.nombre_montura,
+                    montura.imagen,
+                    montura.marca,
+                    montura.color,
+                    montura.material,
+                    montura.id_montura,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Montura actualizada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# delete/monturas -> eliminar una montura con una clase pydantic
+class MonturaDelete(BaseModel):
+    id_montura: int
+
+
+# metodo delete de monturas con manejo de errores
+@router.delete("/")
+def delete_montura(montura: MonturaDelete):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "DELETE FROM Montura WHERE id_montura = ?", (montura.id_montura,)
+            )
+            conn.commit()
+            return {"mensaje": "Montura eliminada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []

routers/monturas_inventario.py

@@ -0,0 +1,160 @@
+from library.librerias import *
+
+router = APIRouter(
+    prefix="/monturas_inventario",
+    tags=["Monturas Inventario"],
+    responses={404: {"description": "No encontrado"}},
+)
+
+
+"""
+CREATE TABLE Montura_inventario (
+  id_montura_inventario INTEGER PRIMARY KEY AUTOINCREMENT,
+  id_montura INTEGER REFERENCES Montura(id_montura),
+  precio_unit REAL,
+  stock INTEGER,
+  codigo VARCHAR
+)
+"""
+
+
+# get/monturas_inventario -> obtener todas las monturas_inventario con with connection as conn, manejo de errores
+@router.get("/")
+def get_monturas_inventario():
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM Montura_inventario")
+            monturas_inventario = cursor.fetchall()
+            return monturas_inventario
+    except Exception as e:
+        print(e)
+        return []
+
+
+# get/monturas_inventario/{id_montura_inventario} -> obtener una montura_inventario por id
+@router.get("/{id_montura_inventario}")
+def get_montura_inventario(id_montura_inventario: int):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM Montura_inventario WHERE id_montura_inventario = ?",
+                (id_montura_inventario,),
+            )
+            montura_inventario = cursor.fetchone()
+            return montura_inventario
+    except Exception as e:
+        print(e)
+        return []
+
+
+# post/monturas_inventario -> crear una montura_inventario con una clase pydantic
+class Montura_inventario(BaseModel):
+    id_montura: int
+    precio_unit: float
+    stock: int
+    codigo: str
+
+
+# metodo post de monturas_inventario con manejo de errores
+@router.post("/")
+def create_montura_inventario(montura_inventario: Montura_inventario):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO Montura_inventario (id_montura, precio_unit, stock, codigo) VALUES (?, ?, ?, ?)",
+                (
+                    montura_inventario.id_montura,
+                    montura_inventario.precio_unit,
+                    montura_inventario.stock,
+                    montura_inventario.codigo,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Montura_inventario creada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# busqueda de montura_inventario por codigo con like, manejo de errores y clase pydantic
+class Montura_inventarioCodigo(BaseModel):
+    codigo: str
+
+
+# post/monturas_inventario/busqueda -> buscar una montura_inventario por codigo
+@router.post("/busqueda")
+def buscar_montura_inventario(montura_inventario: Montura_inventarioCodigo):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM Montura_inventario WHERE codigo LIKE ?",
+                (montura_inventario.codigo,),
+            )
+            montura_inventario = cursor.fetchall()
+            if montura_inventario:
+                return montura_inventario
+            else:
+                raise HTTPException(
+                    status_code=404, detail="Montura_inventario no encontrada"
+                )
+    except Exception as e:
+        print(e)
+        return []
+
+
+# put/monturas_inventario -> actualizar una montura_inventario con una clase pydantic
+class Montura_inventarioUpdate(BaseModel):
+    id_montura_inventario: int
+    id_montura: int
+    precio_unit: float
+    stock: int
+    codigo: str
+
+
+# metodo put de monturas_inventario con manejo de errores
+@router.put("/")
+def update_montura_inventario(montura_inventario: Montura_inventarioUpdate):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE Montura_inventario SET id_montura = ?, precio_unit = ?, stock = ?, codigo = ? WHERE id_montura_inventario = ?",
+                (
+                    montura_inventario.id_montura,
+                    montura_inventario.precio_unit,
+                    montura_inventario.stock,
+                    montura_inventario.codigo,
+                    montura_inventario.id_montura_inventario,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Montura_inventario actualizada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# delete/monturas_inventario -> eliminar una montura_inventario con una clase pydantic
+class Montura_inventarioDelete(BaseModel):
+    id_montura_inventario: int
+
+
+# metodo delete de monturas_inventario con manejo de errores
+@router.delete("/")
+def delete_montura_inventario(montura_inventario: Montura_inventarioDelete):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "DELETE FROM Montura_inventario WHERE id_montura_inventario = ?",
+                (montura_inventario.id_montura_inventario,),
+            )
+            conn.commit()
+            return {"mensaje": "Montura_inventario eliminada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []

routers/monturas_pedido.py

@@ -0,0 +1,133 @@
+from library.librerias import *
+
+router = APIRouter(
+    prefix="/monturas_pedido",
+    tags=["Monturas Pedido"],
+    responses={404: {"description": "No encontrado"}},
+)
+
+
+"""
+CREATE TABLE montura_pedido (
+  id_montura_pedido INTEGER PRIMARY KEY AUTOINCREMENT,
+  id_montura_inventario INTEGER REFERENCES Montura_inventario(id_montura_inventario),
+  cantidad INTEGER,
+  precio REAL,
+  id_boleta INTEGER REFERENCES boleta(id_boleta)
+)
+"""
+
+
+# get/monturas_pedidos -> obtener todas las monturas_pedidos con with connection as conn, manejo de errores
+@router.get("/")
+def get_monturas_pedidos():
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM montura_pedido")
+            monturas_pedidos = cursor.fetchall()
+            return monturas_pedidos
+    except Exception as e:
+        print(e)
+        return []
+
+
+# get/monturas_pedidos/{id_montura_pedido} -> obtener una montura_pedido por id
+@router.get("/{id_montura_pedido}")
+def get_montura_pedido(id_montura_pedido: int):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM montura_pedido WHERE id_montura_pedido = ?",
+                (id_montura_pedido,),
+            )
+            montura_pedido = cursor.fetchone()
+            return montura_pedido
+    except Exception as e:
+        print(e)
+        return []
+
+
+# post/monturas_pedidos -> crear una montura_pedido con una clase pydantic
+class Montura_pedido(BaseModel):
+    id_montura_inventario: int
+    cantidad: int
+    precio: float
+    id_boleta: int
+
+
+# metodo post de monturas_pedidos con manejo de errores
+@router.post("/")
+def create_montura_pedido(montura_pedido: Montura_pedido):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO montura_pedido (id_montura_inventario, cantidad, precio, id_boleta) VALUES (?, ?, ?, ?)",
+                (
+                    montura_pedido.id_montura_inventario,
+                    montura_pedido.cantidad,
+                    montura_pedido.precio,
+                    montura_pedido.id_boleta,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Montura_pedido creada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# put/monturas_pedidos -> actualizar una montura_pedido con una clase pydantic
+class Montura_pedidoUpdate(BaseModel):
+    id_montura_pedido: int
+    id_montura_inventario: int
+    cantidad: int
+    precio: float
+    id_boleta: int
+
+
+# metodo put de monturas_pedidos con manejo de errores
+@router.put("/")
+def update_montura_pedido(montura_pedido: Montura_pedidoUpdate):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE montura_pedido SET id_montura_inventario = ?, cantidad = ?, precio = ?, id_boleta = ? WHERE id_montura_pedido = ?",
+                (
+                    montura_pedido.id_montura_inventario,
+                    montura_pedido.cantidad,
+                    montura_pedido.precio,
+                    montura_pedido.id_boleta,
+                    montura_pedido.id_montura_pedido,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Montura_pedido actualizada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# delete/monturas_pedidos -> eliminar una montura_pedido con una clase pydantic
+class Montura_pedidoDelete(BaseModel):
+    id_montura_pedido: int
+
+
+# metodo delete de monturas_pedidos con manejo de errores
+@router.delete("/")
+def delete_montura_pedido(montura_pedido: Montura_pedidoDelete):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "DELETE FROM montura_pedido WHERE id_montura_pedido = ?",
+                (montura_pedido.id_montura_pedido,),
+            )
+            conn.commit()
+            return {"mensaje": "Montura_pedido eliminada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []

routers/prescripciones.py

@@ -0,0 +1,503 @@
+from library.librerias import *
+
+router = APIRouter(
+    prefix="/prescripciones",
+    tags=["Prescripciones"],
+    responses={404: {"description": "No encontrado"}},
+)
+
+
+# Cargar varias tipografías
+pdfmetrics.registerFont(TTFont("Craftcoke", "./font/Craftcoke.ttf"))
+pdfmetrics.registerFont(TTFont("Oregon", "./font/Oregon.ttf"))
+pdfmetrics.registerFont(TTFont("Roboto", "./font/Roboto.ttf"))
+
+"""
+CREATE TABLE Prescripcion (
+  id_prescripcion INTEGER PRIMARY KEY AUTOINCREMENT,
+  id_medidas INTEGER REFERENCES Medidas(id_medidas),
+  detalle_lunas VARCHAR,
+  fecha VARCHAR
+  
+)
+"""
+
+
+# get/prescripciones -> obtener todas las prescripciones con with connection as conn, manejo de errores
+@router.get("/")
+def get_prescripciones():
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM Prescripcion")
+            prescripciones = cursor.fetchall()
+            return prescripciones
+    except Exception as e:
+        print(e)
+        return []
+
+
+@router.get("/ultimoregistro")
+def get_prescripciones():
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM Prescripcion ORDER BY id_prescripcion DESC LIMIT 1;"
+            )
+            prescripciones = cursor.fetchall()
+            return prescripciones
+    except Exception as e:
+        print(e)
+        return []
+
+
+# get/prescripciones/{id_prescripcion} -> obtener una prescripcion por id
+@router.get("/{id_prescripcion}")
+def get_prescripcion(id_prescripcion: int):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM Prescripcion WHERE id_prescripcion = ?",
+                (id_prescripcion,),
+            )
+            prescripcion = cursor.fetchone()
+            return prescripcion
+    except Exception as e:
+        print(e)
+        return []
+
+
+class Prescripcion(BaseModel):
+    id_medidas: int
+    detalle_lunas: str
+    fecha: str
+
+
+# post prescripcion con pydantic con retorna la todos los datos de la prescripcion
+@router.post("/ultimoRegistro")
+def post_prescripcion(prescripcion: Prescripcion):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO Prescripcion (id_medidas, detalle_lunas, fecha) VALUES (?, ?, ?)",
+                (
+                    prescripcion.id_medidas,
+                    prescripcion.detalle_lunas,
+                    prescripcion.fecha,
+                ),
+            )
+            conn.commit()
+            cursor.execute(
+                "SELECT * FROM Prescripcion ORDER BY id_prescripcion DESC LIMIT 1;"
+            )
+            prescripciones = cursor.fetchall()
+            return prescripciones
+    except Exception as e:
+        print(e)
+        return []
+
+
+# metodo post de prescripciones con manejo de errores
+@router.post("/")
+def create_prescripcion(prescripcion: Prescripcion):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO Prescripcion (id_medidas, detalle_lunas, fecha) VALUES (?, ?, ?)",
+                (
+                    prescripcion.id_medidas,
+                    prescripcion.detalle_lunas,
+                    prescripcion.fecha,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Prescripcion creada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# put/prescripciones -> actualizar una prescripcion con una clase pydantic
+class PrescripcionUpdate(BaseModel):
+    id_prescripcion: int
+    id_medidas: int
+    detalle_lunas: str
+    fecha: str
+
+
+# metodo put de prescripciones con manejo de errores
+@router.put("/")
+def update_prescripcion(prescripcion: PrescripcionUpdate):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE Prescripcion SET id_medidas = ?, detalle_lunas = ?, fecha = ? WHERE id_prescripcion = ?",
+                (
+                    prescripcion.id_medidas,
+                    prescripcion.detalle_lunas,
+                    prescripcion.fecha,
+                    prescripcion.id_prescripcion,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Prescripcion actualizada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# delete/prescripciones -> eliminar una prescripcion con una clase pydantic
+class PrescripcionDelete(BaseModel):
+    id_prescripcion: int
+
+
+# metodo delete de prescripciones con manejo de errores
+@router.delete("/")
+def delete_prescripcion(prescripcion: PrescripcionDelete):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "DELETE FROM Prescripcion WHERE id_prescripcion = ?",
+                (prescripcion.id_prescripcion,),
+            )
+            conn.commit()
+            return {"mensaje": "Prescripcion eliminada exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+def obtener_datos_prescripcion(id_prescripcion):
+    try:
+        conn = DatabaseConnection().get_connection()
+        cursor = conn.cursor()
+        query = """
+        SELECT
+            P.id_prescripcion,
+            P.fecha AS fecha_prescripcion,
+            P.detalle_lunas,
+            Me.Esfera_OD_lejos,
+            Me.Cilindro_OD_lejos,
+            Me.Eje_OD_lejos,
+            Me.Agudeza_visual_OD_lejos,
+            Me.Esfera_OI_lejos,
+            Me.Cilindro_OI_lejos,
+            Me.Eje_OI_lejos,
+            Me.Agudeza_visual_OI_lejos,
+            Me.Esfera_OD_cerca,
+            Me.Cilindro_OD_cerca,
+            Me.Eje_OD_cerca,
+            Me.Agudeza_visual_OD_cerca,
+            Me.Esfera_OI_cerca,
+            Me.Cilindro_OI_cerca,
+            Me.Eje_OI_cerca,
+            Me.Agudeza_visual_OI_cerca,
+            C.id_cliente,
+            C.nombres_y_apellidos,
+            C.edad,
+            C.telefono,
+            C.direccion
+        FROM
+            Prescripcion AS P
+        JOIN
+            Medidas AS Me ON P.id_medidas = Me.id_medidas
+        JOIN
+            Cliente AS C ON Me.id_cliente = C.id_cliente
+        WHERE
+            P.id_prescripcion = ?;
+        """
+        cursor.execute(query, (id_prescripcion,))
+        resultado = cursor.fetchone()
+        return resultado
+    except Exception as e:
+        print(e)
+        return []
+
+
+# crear endpoint para obtener los datos de la prescripción
+@router.get("/prescripcion/{id_prescripcion}")
+def obtener_datos_prescripcion_api(id_prescripcion: int):
+    datos_prescripcion = obtener_datos_prescripcion(id_prescripcion)
+    if datos_prescripcion:
+        # Crear un objeto de la clase DatosPrescripcion
+        obj_datos_prescripcion = DatosPrescripcion(*datos_prescripcion)
+        return obj_datos_prescripcion
+    else:
+        raise HTTPException(status_code=404, detail="Prescripción no encontrada")
+
+
+class DatosPrescripcion:
+    def __init__(
+        self,
+        id_prescripcion,
+        fecha_prescripcion,
+        detalle_lunas,
+        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,
+        nombres_y_apellidos,
+        edad,
+        telefono,
+        direccion,
+    ):
+        """
+        Clase que representa los datos de una prescripción.
+
+        Args:
+            id_prescripcion (int): El ID de la prescripción.
+            fecha_prescripcion (str): La fecha de la prescripción.
+            detalle_lunas (str): Los detalles de las lentes.
+            esfera_od_lejos (float): El valor de la esfera para el ojo derecho en visión lejana.
+            cilindro_od_lejos (float): El valor del cilindro para el ojo derecho en visión lejana.
+            eje_od_lejos (int): El valor del eje para el ojo derecho en visión lejana.
+            agudeza_visual_od_lejos (str): La agudeza visual para el ojo derecho en visión lejana.
+            esfera_oi_lejos (float): El valor de la esfera para el ojo izquierdo en visión lejana.
+            cilindro_oi_lejos (float): El valor del cilindro para el ojo izquierdo en visión lejana.
+            eje_oi_lejos (int): El valor del eje para el ojo izquierdo en visión lejana.
+            agudeza_visual_oi_lejos (str): La agudeza visual para el ojo izquierdo en visión lejana.
+            esfera_od_cerca (float): El valor de la esfera para el ojo derecho en visión cercana.
+            cilindro_od_cerca (float): El valor del cilindro para el ojo derecho en visión cercana.
+            eje_od_cerca (int): El valor del eje para el ojo derecho en visión cercana.
+            agudeza_visual_od_cerca (str): La agudeza visual para el ojo derecho en visión cercana.
+            esfera_oi_cerca (float): El valor de la esfera para el ojo izquierdo en visión cercana.
+            cilindro_oi_cerca (float): El valor del cilindro para el ojo izquierdo en visión cercana.
+            eje_oi_cerca (int): El valor del eje para el ojo izquierdo en visión cercana.
+            agudeza_visual_oi_cerca (str): La agudeza visual para el ojo izquierdo en visión cercana.
+            id_cliente (int): El ID del cliente.
+            nombres_y_apellidos (str): Los nombres y apellidos del cliente.
+            edad (int): La edad del cliente.
+            telefono (str): El número de teléfono del cliente.
+            direccion (str): La dirección del cliente.
+        """
+        self.id_prescripcion = id_prescripcion
+        self.fecha_prescripcion = fecha_prescripcion
+        self.detalle_lunas = detalle_lunas
+        self.esfera_od_lejos = esfera_od_lejos
+        self.cilindro_od_lejos = cilindro_od_lejos
+        self.eje_od_lejos = eje_od_lejos
+        self.agudeza_visual_od_lejos = agudeza_visual_od_lejos
+        self.esfera_oi_lejos = esfera_oi_lejos
+        self.cilindro_oi_lejos = cilindro_oi_lejos
+        self.eje_oi_lejos = eje_oi_lejos
+        self.agudeza_visual_oi_lejos = agudeza_visual_oi_lejos
+        self.esfera_od_cerca = esfera_od_cerca
+        self.cilindro_od_cerca = cilindro_od_cerca
+        self.eje_od_cerca = eje_od_cerca
+        self.agudeza_visual_od_cerca = agudeza_visual_od_cerca
+        self.esfera_oi_cerca = esfera_oi_cerca
+        self.cilindro_oi_cerca = cilindro_oi_cerca
+        self.eje_oi_cerca = eje_oi_cerca
+        self.agudeza_visual_oi_cerca = agudeza_visual_oi_cerca
+        self.id_cliente = id_cliente
+        self.nombres_y_apellidos_cliente = nombres_y_apellidos
+        self.edad_cliente = edad
+        self.telefono_cliente = telefono
+        self.direccion_cliente = direccion
+
+    def generar_pdf(self, filename):
+        """
+        Genera un archivo PDF con los datos de la prescripción.
+
+        Args:
+            filename (str): El nombre del archivo PDF a generar.
+        """
+        pdf = canvas.Canvas(filename)
+        pdf.setFont("Oregon", 12)
+        ubicacion_inicio = 780  # Posición inicial en y
+        pdf.drawCentredString(
+            300, ubicacion_inicio, "OPTICA ARTE VISUAL - PRESCRIPCIÓN"
+        )
+        pdf.drawString(
+            100,
+            ubicacion_inicio - 40,
+            f"Nombre del Cliente: {self.nombres_y_apellidos_cliente}",
+        )
+        pdf.drawString(
+            100, ubicacion_inicio - 60, f"Datos del cliente: {self.direccion_cliente}"
+        )
+        pdf.drawString(
+            100, ubicacion_inicio - 80, f"Número telefónico: {self.telefono_cliente}"
+        )
+        pdf.drawString(
+            100,
+            ubicacion_inicio - 100,
+            f"Código de prescripción: {self.id_prescripcion}",
+        )
+        pdf.drawString(100, ubicacion_inicio - 120, f"Fecha: {self.fecha_prescripcion}")
+        pdf.drawString(
+            100, ubicacion_inicio - 140, f"Descripción: {self.detalle_lunas}"
+        )
+        ubicacion_esfera = 150  # Posición inicial en x
+        ubicacion_cilindro = ubicacion_esfera + 65  # Posición inicial en x + 65
+        ubicacion_eje = ubicacion_cilindro + 75  # Posición anterior en x + 75
+        ubicacion_agudeza = ubicacion_eje + 70  # Posición anterior en x + 70
+        tabla_medidas = ubicacion_inicio - 170  # Posición inicial en y
+
+        pdf.drawString(ubicacion_esfera - 50, tabla_medidas, "Tabla de medidas:")
+        # Para el ojo izquierdo de lejos
+        pdf.drawString(
+            ubicacion_esfera + 100, tabla_medidas - 20, "Ojo izquierdo de lejos"
+        )
+        pdf.line(
+            x1=ubicacion_esfera,
+            y1=tabla_medidas - 25,
+            x2=ubicacion_esfera + 300,
+            y2=tabla_medidas - 25,
+        )
+        pdf.drawString(ubicacion_esfera, tabla_medidas - 40, "Esfera")
+        pdf.drawString(ubicacion_cilindro, tabla_medidas - 40, "Cilindro")
+        pdf.drawString(ubicacion_eje, tabla_medidas - 40, "Eje")
+        pdf.drawString(ubicacion_agudeza, tabla_medidas - 40, "Agudeza visual")
+        pdf.drawString(ubicacion_esfera, tabla_medidas - 60, f"{self.esfera_oi_lejos}")
+        pdf.drawString(
+            ubicacion_cilindro, tabla_medidas - 60, f"{self.cilindro_oi_lejos}"
+        )
+        pdf.drawString(ubicacion_eje, tabla_medidas - 60, f"{self.eje_oi_lejos}")
+        pdf.drawString(
+            ubicacion_agudeza, tabla_medidas - 60, f"{self.agudeza_visual_oi_lejos}"
+        )
+        # Para el ojo derecho de lejos
+        odl = tabla_medidas - 100  # Posición inicial en y
+        pdf.drawString(ubicacion_esfera + 100, odl, "Ojo derecho de lejos")
+        pdf.line(x1=ubicacion_esfera, y1=odl - 5, x2=ubicacion_esfera + 300, y2=odl - 5)
+        pdf.drawString(ubicacion_esfera, odl - 20, "Esfera")
+        pdf.drawString(ubicacion_cilindro, odl - 20, "Cilindro")
+        pdf.drawString(ubicacion_eje, odl - 20, "Eje")
+        pdf.drawString(ubicacion_agudeza, odl - 20, "Agudeza visual")
+        pdf.drawString(ubicacion_esfera, odl - 40, f"{self.esfera_od_lejos}")
+        pdf.drawString(ubicacion_cilindro, odl - 40, f"{self.cilindro_od_lejos}")
+        pdf.drawString(ubicacion_eje, odl - 40, f"{self.eje_od_lejos}")
+        pdf.drawString(ubicacion_agudeza, odl - 40, f"{self.agudeza_visual_od_lejos}")
+
+        oic = odl - 80  # Posición inicial en y
+        pdf.drawString(ubicacion_esfera + 100, oic, "Ojo izquierdo de cerca")
+        pdf.line(x1=ubicacion_esfera, y1=oic - 5, x2=ubicacion_esfera + 300, y2=oic - 5)
+        # Para el ojo izquierdo de cerca
+        pdf.drawString(ubicacion_esfera, oic - 20, "Esfera")
+        pdf.drawString(ubicacion_cilindro, oic - 20, "Cilindro")
+        pdf.drawString(ubicacion_eje, oic - 20, "Eje")
+        pdf.drawString(ubicacion_agudeza, oic - 20, "Agudeza visual")
+        pdf.drawString(ubicacion_esfera, oic - 40, f"{self.esfera_oi_cerca}")
+        pdf.drawString(ubicacion_cilindro, oic - 40, f"{self.cilindro_oi_cerca}")
+        pdf.drawString(ubicacion_eje, oic - 40, f"{self.eje_oi_cerca}")
+        pdf.drawString(ubicacion_agudeza, oic - 40, f"{self.agudeza_visual_oi_cerca}")
+        odc = oic - 80
+        pdf.drawString(ubicacion_esfera + 100, odc, "Ojo derecho de cerca")
+        pdf.line(x1=ubicacion_esfera, y1=odc - 5, x2=ubicacion_esfera + 300, y2=odc - 5)
+        # Para el ojo derecho de cerca
+        pdf.drawString(ubicacion_esfera, odc - 20, "Esfera")
+        pdf.drawString(ubicacion_cilindro, odc - 20, "Cilindro")
+        pdf.drawString(ubicacion_eje, odc - 20, "Eje")
+        pdf.drawString(ubicacion_agudeza, odc - 20, "Agudeza visual")
+        pdf.drawString(ubicacion_esfera, odc - 40, f"{self.esfera_od_cerca}")
+        pdf.drawString(ubicacion_cilindro, odc - 40, f"{self.cilindro_od_cerca}")
+        pdf.drawString(ubicacion_eje, odc - 40, f"{self.eje_od_cerca}")
+        pdf.drawString(ubicacion_agudeza, odc - 40, f"{self.agudeza_visual_od_cerca}")
+
+        # Calcular el centro de la página
+        centro_pagina = pdf._pagesize[0] / 2
+
+        # Texto y línea centrados
+        texto_firma = "        Firma o sello:         "
+        ancho_texto = pdf.stringWidth(texto_firma, "Helvetica", 12)
+        inicio_linea = centro_pagina - ancho_texto / 2
+        fin_linea = inicio_linea + ancho_texto
+        # ubicacion en y dependiendo de la tabla de medidas
+        firma_ubicacion = odc - 70
+        pdf.drawString(inicio_linea, firma_ubicacion, texto_firma)
+        pdf.line(inicio_linea, firma_ubicacion - 50, fin_linea, firma_ubicacion - 50)
+
+        pdf.save()
+        print(f"PDF generado: {filename}")
+
+
+# endpoint descargar prescripcion pdf con clase
+class PrescripcionPDF(BaseModel):
+    id_prescripcion: int
+
+
+@router.post("/prescripcion/pdf")
+def obtener_pdf_prescripcion_api(prescripcion: PrescripcionPDF):
+    datos_prescripcion = obtener_datos_prescripcion(prescripcion.id_prescripcion)
+    if datos_prescripcion:
+        # Crear un objeto de la clase DatosPrescripcion
+        obj_datos_prescripcion = DatosPrescripcion(*datos_prescripcion)
+        directorio_pdf = "pdf/prescripcion/"
+        os.makedirs(directorio_pdf, exist_ok=True)
+        # obtener la fecha de hoy
+        fecha_hoy = date.today()
+        # generar el nombre del archivo
+        nombre_archivo = f"{directorio_pdf}prescripcion_{prescripcion.id_prescripcion}_{fecha_hoy}.pdf"
+
+        obj_datos_prescripcion.generar_pdf(f"{nombre_archivo}")
+        return FileResponse(
+            nombre_archivo, media_type="routerlication/pdf", filename=nombre_archivo
+        )
+    else:
+        raise HTTPException(status_code=404, detail="Prescripción no encontrada")
+
+
+# crear endpoint retornando la url del PDF con los datos de la prescripción
+@router.get("/prescripcion/pdf/{id_prescripcion}")
+def ver_prescripcion_pdf(id_prescripcion: int):
+    datos_prescripcion = obtener_datos_prescripcion(id_prescripcion)
+    if datos_prescripcion:
+        # Crear un objeto de la clase DatosPrescripcion
+        obj_datos_prescripcion = DatosPrescripcion(*datos_prescripcion)
+        directorio_pdf = "pdf/prescripcion/"
+        os.makedirs(directorio_pdf, exist_ok=True)
+        # obtener la fecha de hoy
+        fecha_hoy = date.today()
+        # generar el nombre del archivo
+        nombre_archivo = (
+            f"{directorio_pdf}prescripcion_{id_prescripcion}_{fecha_hoy}.pdf"
+        )
+        obj_datos_prescripcion.generar_pdf(f"{nombre_archivo}")
+        return FileResponse(path=nombre_archivo)
+    else:
+        raise HTTPException(status_code=404, detail="Prescripción no encontrada")
+
+
+# metodo get pdf de prescripcion
+@router.get("/prescripcion/descargarPDF/{id_prescripcion}")
+def descargar_prescripcion_pdf(id_prescripcion: int):
+    datos_prescripcion = obtener_datos_prescripcion(id_prescripcion)
+    if datos_prescripcion:
+        # Crear un objeto de la clase DatosPrescripcion
+        obj_datos_prescripcion = DatosPrescripcion(*datos_prescripcion)
+        directorio_pdf = "pdf/prescripcion/"
+        os.makedirs(directorio_pdf, exist_ok=True)
+        # obtener la fecha de hoy
+        fecha_hoy = date.today()
+        # generar el nombre del archivo
+        nombre_archivo = (
+            f"{directorio_pdf}prescripcion_{id_prescripcion}_{fecha_hoy}.pdf"
+        )
+        obj_datos_prescripcion.generar_pdf(f"{nombre_archivo}")
+        return FileResponse(
+            path=nombre_archivo,
+            media_type="routerlication/pdf",
+            filename=nombre_archivo,
+        )
+    else:
+        raise HTTPException(status_code=404, detail="Prescripción no encontrada")

routers/roles.py

@@ -0,0 +1,123 @@
+from library.librerias import *
+
+router = APIRouter(
+    prefix="/roles", tags=["Roles"], responses={404: {"description": "No encontrado"}}
+)
+
+"""
+CREATE TABLE Roles (
+  id_rol INTEGER PRIMARY KEY AUTOINCREMENT,
+  rol VARCHAR
+)
+"""
+
+
+@router.get("/")
+def get_roles():
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM Roles")
+            roles = cursor.fetchall()
+            if roles:
+                return roles
+            else:
+                raise HTTPException(status_code=404, detail="Roles no encontrado")
+    except Exception as e:
+        print(e)
+        return []
+
+
+@router.get("/{id_rol}")
+def get_rol(id_rol: int):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM Roles WHERE id_rol = ?", (id_rol,))
+            rol = cursor.fetchone()
+            if rol:
+                return rol
+            else:
+                raise HTTPException(status_code=404, detail="Rol no encontrado")
+    except Exception as e:
+        print(e)
+        return []
+
+
+class RolNombre(BaseModel):
+    rol: str
+
+
+@router.post("/busqueda")
+def buscar_rol(rol: RolNombre):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM Roles WHERE rol = ?", (rol.rol,))
+            rol = cursor.fetchone()
+            # retornar el rol encontrado o un mensaje de error con HTTPException
+            if rol:
+                return rol
+            else:
+                raise HTTPException(status_code=404, detail="Rol no encontrado")
+    except Exception as e:
+        print(e)
+        return []
+
+
+# post/roles -> crear un rol con una clase pydantic
+class Rol(BaseModel):
+    rol: str
+
+
+# post/roles -> crear un rol con una clase pydantic
+@router.post("/")
+def create_rol(rol: Rol):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("INSERT INTO Roles (rol) VALUES (?)", (rol.rol,))
+            conn.commit()
+            return {"mensaje": "Rol creado exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# put/roles -> actualizar un rol con una clase pydantic
+class RolUpdate(BaseModel):
+    id_rol: int
+    rol: str
+
+
+@router.put("/")
+def update_rol(rol: RolUpdate):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE Roles SET rol = ? WHERE id_rol = ?", (rol.rol, rol.id_rol)
+            )
+            conn.commit()
+            return {"mensaje": "Rol actualizado exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# delete/roles -> eliminar un rol con una clase pydantic
+class RolDelete(BaseModel):
+    id_rol: int
+
+
+@router.delete("/")
+def delete_rol(rol: RolDelete):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("DELETE FROM Roles WHERE id_rol = ?", (rol.id_rol,))
+            conn.commit()
+            return {"mensaje": "Rol eliminado exitosamente"}
+    except Exception as e:
+        print(e)
+        return []

routers/routers.py

@@ -0,0 +1,13 @@
+from routers import (
+    comprobante_pago,
+    roles,
+    usuarios,
+    clientes,
+    medidas,
+    prescripciones,
+    lunas_pedido,
+    monturas,
+    monturas_inventario,
+    boletas,
+    monturas_pedido,
+)

routers/usuarios.py

@@ -0,0 +1,155 @@
+from library.librerias import *
+
+router = APIRouter(
+    prefix="/usuarios",
+    tags=["Usuarios"],
+    responses={404: {"description": "No encontrado"}},
+)
+
+"""
+CREATE TABLE Usuario (
+  id_usuario INTEGER PRIMARY KEY AUTOINCREMENT,
+  nombre_usuario VARCHAR,
+  dni VARCHAR,
+  clave VARCHAR,
+  id_rol INTEGER REFERENCES Roles(id_rol),
+  estado VARCHAR
+)
+"""
+
+
+# get/usuarios -> obtener todos los usuarios con with connection as conn, manejo de errores
+@router.get("/")
+def get_usuarios():
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM Usuario")
+            usuarios = cursor.fetchall()
+            return usuarios
+    except Exception as e:
+        print(e)
+        return []
+
+
+# get/usuarios/{id_usuario} -> obtener un usuario por id
+@router.get("/{id_usuario}")
+def get_usuario(id_usuario: int):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM Usuario WHERE id_usuario = ?", (id_usuario,))
+            usuario = cursor.fetchone()
+            return usuario
+    except Exception as e:
+        print(e)
+        return []
+
+
+# metodo de busqueda de usuario por nombre con like, manejo de errores y clase pydantic
+class UsuarioNombre(BaseModel):
+    nombre_usuario: str
+
+
+# post/usuarios/busqueda -> buscar usuario por nombre con like
+@router.post("/busqueda")
+def buscar_usuario(usuario: UsuarioNombre):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM Usuario WHERE nombre_usuario LIKE ?",
+                ["%" + usuario.nombre_usuario + "%"],
+            )
+            usuario = cursor.fetchall()
+            if usuario:
+                return usuario
+            else:
+                raise HTTPException(status_code=404, detail="Usuario no encontrado")
+    except Exception as e:
+        print(e)
+        return []
+
+
+# post/usuarios -> crear un usuario con una clase pydantic
+class Usuario(BaseModel):
+    nombre_usuario: str
+    dni: str
+    clave: str
+    id_rol: int
+    estado: str
+
+
+@router.post("/")
+def create_usuario(usuario: Usuario):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO Usuario (nombre_usuario, dni, clave, id_rol, estado) VALUES (?, ?, ?, ?, ?)",
+                (
+                    usuario.nombre_usuario,
+                    usuario.dni,
+                    usuario.clave,
+                    usuario.id_rol,
+                    usuario.estado,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Usuario creado exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# put/usuarios -> actualizar un usuario con una clase pydantic
+class UsuarioUpdate(BaseModel):
+    id_usuario: int
+    nombre_usuario: str
+    dni: str
+    clave: str
+    id_rol: int
+    estado: str
+
+
+@router.put("/")
+def update_usuario(usuario: UsuarioUpdate):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "UPDATE Usuario SET nombre_usuario = ?, dni = ?, clave = ?, id_rol = ?, estado = ? WHERE id_usuario = ?",
+                (
+                    usuario.nombre_usuario,
+                    usuario.dni,
+                    usuario.clave,
+                    usuario.id_rol,
+                    usuario.estado,
+                    usuario.id_usuario,
+                ),
+            )
+            conn.commit()
+            return {"mensaje": "Usuario actualizado exitosamente"}
+    except Exception as e:
+        print(e)
+        return []
+
+
+# delete/usuarios -> eliminar un usuario con una clase pydantic
+class UsuarioDelete(BaseModel):
+    id_usuario: int
+
+
+@router.delete("/")
+def delete_usuario(usuario: UsuarioDelete):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "DELETE FROM Usuario WHERE id_usuario = ?", (usuario.id_usuario,)
+            )
+            conn.commit()
+            return {"mensaje": "Usuario eliminado exitosamente"}
+    except Exception as e:
+        print(e)
+        return []