eliminado de t.gama, t.montura quitar id_gama y agregar marca,color, material

.gitignore

@@ -0,0 +1 @@
+__pycache__ 

Dockerfile

@@ -0,0 +1,15 @@
+# Usa una imagen base de Python
+FROM python:3.9
+# Establece el directorio de trabajo
+WORKDIR /code
+
+# Copia los archivos necesarios al contenedor
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir -r /code/requirements.txt
+
+COPY . .
+
+RUN chmod -R 777 /code
+
+# Comando para ejecutar la aplicación
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,1280 @@
+import sqlite3
+import threading
+from queue import Queue
+from pydantic import BaseModel
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi import FastAPI, HTTPException
+
+
+app = FastAPI()
+
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    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.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
+
+
+# saludo
+@app.get("/")
+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()
+            return roles
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@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()
+            return rol
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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()
+            return rol
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+"""
+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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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 un usuario por nombre
+@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.fetchone()
+            return usuario
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+"""
+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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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 buscar_cliente(cliente: ClienteNombre):
+    try:
+        with DatabaseConnection().get_connection() as conn:
+            cursor = conn.cursor()
+            cursor.execute(
+                "SELECT * FROM Cliente WHERE nombres_y_apellidos LIKE ?",
+                (cliente.nombres_y_apellidos,),
+            )
+            cliente = cursor.fetchone()
+            return cliente
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+"""
+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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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.fetchone()
+            return medida
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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 {"mensaje": "Error al crear la medida"}
+
+
+# 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 {"mensaje": "Error al actualizar la medida"}
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+"""
+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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# post/prescripciones -> crear una prescripcion con una clase pydantic
+class Prescripcion(BaseModel):
+    id_medidas: int
+    detalle_lunas: str
+    fecha: str
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+"""
+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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# busqueda de montura por nombre con like, manejo de errores y clase pydantic
+class MonturaNombre(BaseModel):
+    nombre_montura: str
+
+
+# post/monturas/busqueda -> buscar una 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.fetchone()
+            return montura
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+"""
+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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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.fetchone()
+            return montura_inventario
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+"""
+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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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()
+            return boleta
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+"""
+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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# 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:
+        raise HTTPException(status_code=500, detail=str(e))

requirements.txt

@@ -0,0 +1,3 @@
+fastapi
+uvicorn
+reportlab

tablas.py

@@ -0,0 +1,148 @@
+import sqlite3
+
+# Conectar a la base de datos (o crearla si no existe)
+conn = sqlite3.connect("optica.db")
+cursor = conn.cursor()
+
+# Crear la tabla Roles
+cursor.execute(
+    """
+CREATE TABLE Roles (
+  id_rol INTEGER PRIMARY KEY AUTOINCREMENT,
+  rol VARCHAR
+)
+"""
+)
+
+# Crear la tabla Boleta
+cursor.execute(
+    """
+CREATE TABLE boleta (
+  id_boleta INTEGER PRIMARY KEY AUTOINCREMENT,
+  precio_total REAL,
+  estado_recojo VARCHAR
+)
+"""
+)
+
+# Crear la tabla Cliente
+cursor.execute(
+    """
+CREATE TABLE Cliente (
+  id_cliente INTEGER PRIMARY KEY AUTOINCREMENT,
+  nombres_y_apellidos VARCHAR,
+  edad INTEGER,
+  telefono INTEGER,
+  direccion VARCHAR
+)
+"""
+)
+
+# Crear la tabla Usuario
+cursor.execute(
+    """
+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
+)
+"""
+)
+
+# Crear la tabla Medidas
+cursor.execute(
+    """
+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)
+)
+"""
+)
+
+# Crear la tabla Prescripcion
+cursor.execute(
+    """
+CREATE TABLE Prescripcion (
+  id_prescripcion INTEGER PRIMARY KEY AUTOINCREMENT,
+  id_medidas INTEGER REFERENCES Medidas(id_medidas),
+  detalle_lunas VARCHAR,
+  fecha VARCHAR
+)
+"""
+)
+
+# Crear la tabla lunas_pedido
+cursor.execute(
+    """
+CREATE TABLE lunas_pedido (
+  id_lunas_pedido INTEGER PRIMARY KEY AUTOINCREMENT,
+  id_prescripcion INTEGER REFERENCES Prescripcion(id_prescripcion),
+  precio REAL,
+  id_boleta INTEGER REFERENCES boleta(id_boleta),
+  descripcion VARCHAR
+)
+"""
+)
+
+# Crear la tabla Montura
+cursor.execute(
+    """
+CREATE TABLE Montura (
+  id_montura INTEGER PRIMARY KEY AUTOINCREMENT,
+  nombre_montura VARCHAR,
+  imagen VARCHAR,
+  marca VARCHAR,
+  color VARCHAR,
+  material VARCHAR
+)
+"""
+)
+
+# Crear la tabla Montura_inventario
+cursor.execute(
+    """
+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
+)
+"""
+)
+
+# Crear la tabla montura_pedido
+cursor.execute(
+    """
+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)
+)
+"""
+)
+
+# Confirmar y cerrar la conexión
+conn.commit()
+conn.close()