DI_U3.Controladores.mostrarReservasControlador

  1import sys
  2import os
  3
  4sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
  5
  6from Controladores.reservarControlador import ReservarControlador
  7from PySide6.QtCore import Qt
  8from PySide6.QtWidgets import QMainWindow, QMessageBox, QTableWidgetItem # type: ignore
  9from PySide6.QtWidgets import QApplication # type: ignore
 10from Vistas.mostrarReservas import Ui_nlgReservas
 11#from Vistas.reservar import Ui_nlgConfirmarReserva
 12from Conexion_BBDD.connectionBBDD import Connectionbd # type: ignore
 13from Controladores.modificarReservaControlador import ModificarReservaControlador
 14import sqlite3
 15
 16
 17class MostrarReservasControlador(QMainWindow):
 18
 19    """
 20        Interfaz 2, en la que se selecciona el tipo de salón que buscamos para reservas
 21        y celebrar un evento, si no se selecciona ningún tipo de salón no debe poder
 22        acceder a la interfaz 3 
 23
 24        Métodos:
 25        cargarSalones():carga los salones que hay en la base de datos
 26        abrirReserva(): abrir la ventana 3
 27        cargarReservas(tipoSalon): carga reservas asociadas a cada tipo de salon seleccionado
 28        """
 29
 30    def __init__(self, parent=None):
 31
 32        """
 33        Inicializa la interfaz y configura la conexion con la base de datos
 34        cargando los tipos de salones y las reservas que tienen
 35        """
 36        
 37        super().__init__(parent)
 38        self.ui = Ui_nlgReservas()
 39        self.ui.setupUi(self)
 40
 41        # Conectar los eventos con las funciones
 42        self.ui.pushButtonReserva.clicked.connect(self.abrirReserva)
 43        self.ui.comboBoxSalones.currentTextChanged.connect(self.cargarReservas)
 44        self.ui.pushButtonModificar.clicked.connect(self.modificar_reserva)
 45
 46        # Iniciar la conexión con la BBDD
 47        self.db_path = "Conexion_BBDD/reservasHotel.sql"
 48        self.dbManager = Connectionbd(self.db_path)
 49       
 50
 51        # Cargar los salones desde la base de datos
 52        self.cargarSalones()
 53
 54        # Establecer el valor por defecto en el comboBox
 55        self.ui.comboBoxSalones.setCurrentIndex(0)  # Establece el primer ítem como seleccionado
 56
 57    def cargarSalones(self):
 58        """
 59        carga los salones disponibles en la base de datos y añade al comboBox
 60        """
 61        
 62        # Realizar la consulta a la base de datos para obtener los salones
 63        salones= self.dbManager.get_salones()
 64        
 65        # Limpiar el comboBox antes de agregar nuevos datos
 66        self.ui.comboBoxSalones.clear()
 67        
 68        # Agregar un valor por defecto al comboBox
 69        self.ui.comboBoxSalones.addItem("Selecciona un salón")
 70        
 71        # Agregar los salones obtenidos de la base de datos
 72        for salon_id, salon_nombre in salones:
 73            self.ui.comboBoxSalones.addItem(salon_nombre, salon_id)
 74        
 75    
 76    def abrirReserva(self):
 77        """
 78        Abrir la interfaz de reserva (Ventana 3) pero verifica antes que se haya seleccionado
 79        un salón de los que hay en la base de datos
 80        """
 81        # Verificar que haya 1 salón seleccionado
 82        salon_id = self.ui.comboBoxSalones.currentData()  # Obtiene el salon_id, no solo el texto
 83        tipoSalon = self.ui.comboBoxSalones.currentText()
 84
 85        if tipoSalon == "Selecciona un salón":
 86            QMessageBox.warning(self, 
 87                "Advertencia",
 88                "Debes seleccionar un salón para la reserva."
 89            )
 90            return  # Salir si no hay salón seleccionado
 91
 92        # Para abrir la ventana de reserva y pasar el el salon_id
 93        self.ventana3=ReservarControlador(salon_id=salon_id)
 94        self.ventana3.show()
 95
 96
 97    def cargarReservas(self, tipoSalon):
 98        """
 99        Carga las reservas que hay en la base de datos asociadas a cada tipo de salon
100        """
101       
102        # Vaciar la tabla para cargar los nuevos datos
103        self.ui.tableWidget.setRowCount(0)
104
105        # Verificar que no se cargue nada si el usuario no selecciona un salón válido
106        if tipoSalon == "Selecciona un salón":
107            return
108
109        # Limpiar espacios en blanco extra antes de hacer la consulta
110        tipoSalon = tipoSalon.strip()
111        print(f"Consultando reservas para el salón: '{tipoSalon}'")
112
113         # Crear una instancia de la clase Connectionbd y obtener las reservas para el salón seleccionado
114        conexion_bd = Connectionbd(self.db_path)  # Suponiendo que self.db_path es la ubicación de la base de datos
115        reservas = conexion_bd.get_reservasSalon(tipoSalon)
116        print(f"Reservas encontradas: {len(reservas)}")
117
118        # Comprobamos si no se encontraron reservas
119        if not reservas:
120            print(f"No se encontraron reservas para el salón: {tipoSalon}")
121            return  # No se hace nada si no hay resultados
122
123        # Configurar el número de columnas de la tabla a 4 (para las 4 columnas que vamos a mostrar)
124        self.ui.tableWidget.setColumnCount(5)#una columna de + para ocultar id
125
126        # Agregar cada reserva a la tabla
127        for row_number, row_data in enumerate(reservas):
128            self.ui.tableWidget.insertRow(row_number)
129          
130            
131
132              # Extraer los datos de la reserva
133            reserva_id = row_data [0] # Si tienes un ID real, usa ese valor aquí
134            fecha = row_data[1]  # Suponiendo que 'fecha' es la primera columna en la consulta
135            persona = row_data[2]  # Suponiendo que 'persona' es la segunda columna
136            telefono = row_data[3]  # Suponiendo que 'telefono' es la tercera columna
137            tipo_reserva_id = row_data[4]  # Suponiendo que 'tipo_reserva_id' es la cuarta columna
138
139            # Insertar el valor del reserva_id en la primera columna (ahora visible)
140            self.ui.tableWidget.setItem(row_number, 0, QTableWidgetItem(str(reserva_id)))
141
142            # Insertar el valor de la fecha en la segunda columna
143            self.ui.tableWidget.setItem(row_number, 1, QTableWidgetItem(str(fecha)))
144            # Insertar el valor de la persona en la tercera columna
145            self.ui.tableWidget.setItem(row_number, 2, QTableWidgetItem(str(persona)))
146            # Insertar el valor del teléfono en la cuarta columna
147            self.ui.tableWidget.setItem(row_number, 3, QTableWidgetItem(str(telefono)))
148            # Insertar el valor del tipo de reserva en la quinta columna
149            self.ui.tableWidget.setItem(row_number, 4, QTableWidgetItem(str(tipo_reserva_id)))   
150            
151        # Configurar los encabezados de las columnas (solo una vez)
152        self.ui.tableWidget.setHorizontalHeaderLabels(["ID","Fecha", "Persona", "Teléfono", "Tipo Reserva"])
153
154        # Ocultar la columna del ID
155       # self.ui.tableWidget.setColumnHidden(0, True)
156
157        # Ajustar el tamaño de las columnas para que se ajusten al contenido
158        self.ui.tableWidget.resizeColumnsToContents()
159
160            
161        # Forzar actualización de la tabla
162       # self.ui.tableWidget.repaint() 
163
164    def modificar_reserva(self):
165        """
166        Abre la interfaz 4 (ModificarReservaControlador) al hacer clic en el botón "Modificar Reserva".
167        Hay que seleccionar un dato de la fila que se desea modificar.
168     """
169       
170         # Obtener la fila seleccionada
171        row = self.ui.tableWidget.currentRow()
172        if row == -1:
173            QMessageBox.warning(self, "Advertencia", "Por favor, selecciona una reserva para modificar.")
174            return
175
176         # Obtener el reserva_id desde la fila seleccionada (este es el valor oculto en la tabla)
177        reserva_id = self.ui.tableWidget.item(row, 0) 
178        if not reserva_id:
179            QMessageBox.critical(self, "Error", "No se pudo obtener el ID de la reserva seleccionada.")
180            return
181        reserva_id=reserva_id.text()
182        print(f"ID de la reserva seleccionada: {reserva_id}")
183
184        # Ahora obtenemos todos los datos completos de la reserva usando reserva_id
185        try:
186            conexion = sqlite3.connect(self.db_path)
187            cursor = conexion.cursor()
188
189            cursor.execute("""
190                SELECT persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, ocupacion, jornadas, habitaciones
191                FROM reservas
192                WHERE reserva_id = ?
193            """, (reserva_id,))
194
195            datos_reserva = cursor.fetchone()
196            #conexion.close()
197
198            if  datos_reserva:
199                 # Ahora pasamos los datos completos a la ventana de modificación
200                persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, ocupacion, jornadas, habitaciones = datos_reserva
201            else:
202                QMessageBox.warning(self, "Error", "No se encontró la reserva con ese ID.")
203                return
204
205           
206            # Crear una instancia de la ventana de modificación y pasarle los datos
207            datos_completos = {
208                "persona": persona,
209                "telefono": telefono,
210                "fecha": fecha,
211                "tipo_reserva_id": tipo_reserva_id,
212                "tipo_cocina_id": tipo_cocina_id,
213                "ocupacion": ocupacion,
214                "jornadas": jornadas,
215                "habitaciones": habitaciones
216            }
217
218            self.ventana4 = ModificarReservaControlador(datos_reserva=datos_completos, reserva_id=reserva_id)
219            self.ventana4.show()
220
221        except sqlite3.Error as e:
222            QMessageBox.critical(self, "Error", f"No se pudo cargar los datos de la reserva: {e}")
223
224    def obtener_datos_reserva(self, reserva_id):
225        """
226        Obtiene los datos completos de una reserva usando su ID.
227        """
228        try:
229            conexion = sqlite3.connect(self.db_path)
230            cursor = conexion.cursor()
231
232            cursor.execute("""
233                SELECT persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, ocupacion, jornadas, habitaciones
234                FROM reservas
235                WHERE reserva_id = ?
236                ORDER BY fecha DESC
237            """, (reserva_id,))
238
239            # Obtener los resultados
240            datos_reserva = cursor.fetchone()
241
242            conexion.close()
243
244            # Si no se encontró la reserva, devolver None
245            if not datos_reserva:
246                return None
247
248            return datos_reserva
249
250        except sqlite3.Error as e:
251            QMessageBox.critical(self, "Error", f"No se pudo obtener los datos de la reserva: {e}")
252            return None
253
254    
255if __name__ == "__main__":
256    import sys
257    app = QApplication([])
258    ventana = MostrarReservasControlador()
259    ventana.show()
260    app.exec()
class MostrarReservasControlador(PySide6.QtWidgets.QMainWindow):
 18class MostrarReservasControlador(QMainWindow):
 19
 20    """
 21        Interfaz 2, en la que se selecciona el tipo de salón que buscamos para reservas
 22        y celebrar un evento, si no se selecciona ningún tipo de salón no debe poder
 23        acceder a la interfaz 3 
 24
 25        Métodos:
 26        cargarSalones():carga los salones que hay en la base de datos
 27        abrirReserva(): abrir la ventana 3
 28        cargarReservas(tipoSalon): carga reservas asociadas a cada tipo de salon seleccionado
 29        """
 30
 31    def __init__(self, parent=None):
 32
 33        """
 34        Inicializa la interfaz y configura la conexion con la base de datos
 35        cargando los tipos de salones y las reservas que tienen
 36        """
 37        
 38        super().__init__(parent)
 39        self.ui = Ui_nlgReservas()
 40        self.ui.setupUi(self)
 41
 42        # Conectar los eventos con las funciones
 43        self.ui.pushButtonReserva.clicked.connect(self.abrirReserva)
 44        self.ui.comboBoxSalones.currentTextChanged.connect(self.cargarReservas)
 45        self.ui.pushButtonModificar.clicked.connect(self.modificar_reserva)
 46
 47        # Iniciar la conexión con la BBDD
 48        self.db_path = "Conexion_BBDD/reservasHotel.sql"
 49        self.dbManager = Connectionbd(self.db_path)
 50       
 51
 52        # Cargar los salones desde la base de datos
 53        self.cargarSalones()
 54
 55        # Establecer el valor por defecto en el comboBox
 56        self.ui.comboBoxSalones.setCurrentIndex(0)  # Establece el primer ítem como seleccionado
 57
 58    def cargarSalones(self):
 59        """
 60        carga los salones disponibles en la base de datos y añade al comboBox
 61        """
 62        
 63        # Realizar la consulta a la base de datos para obtener los salones
 64        salones= self.dbManager.get_salones()
 65        
 66        # Limpiar el comboBox antes de agregar nuevos datos
 67        self.ui.comboBoxSalones.clear()
 68        
 69        # Agregar un valor por defecto al comboBox
 70        self.ui.comboBoxSalones.addItem("Selecciona un salón")
 71        
 72        # Agregar los salones obtenidos de la base de datos
 73        for salon_id, salon_nombre in salones:
 74            self.ui.comboBoxSalones.addItem(salon_nombre, salon_id)
 75        
 76    
 77    def abrirReserva(self):
 78        """
 79        Abrir la interfaz de reserva (Ventana 3) pero verifica antes que se haya seleccionado
 80        un salón de los que hay en la base de datos
 81        """
 82        # Verificar que haya 1 salón seleccionado
 83        salon_id = self.ui.comboBoxSalones.currentData()  # Obtiene el salon_id, no solo el texto
 84        tipoSalon = self.ui.comboBoxSalones.currentText()
 85
 86        if tipoSalon == "Selecciona un salón":
 87            QMessageBox.warning(self, 
 88                "Advertencia",
 89                "Debes seleccionar un salón para la reserva."
 90            )
 91            return  # Salir si no hay salón seleccionado
 92
 93        # Para abrir la ventana de reserva y pasar el el salon_id
 94        self.ventana3=ReservarControlador(salon_id=salon_id)
 95        self.ventana3.show()
 96
 97
 98    def cargarReservas(self, tipoSalon):
 99        """
100        Carga las reservas que hay en la base de datos asociadas a cada tipo de salon
101        """
102       
103        # Vaciar la tabla para cargar los nuevos datos
104        self.ui.tableWidget.setRowCount(0)
105
106        # Verificar que no se cargue nada si el usuario no selecciona un salón válido
107        if tipoSalon == "Selecciona un salón":
108            return
109
110        # Limpiar espacios en blanco extra antes de hacer la consulta
111        tipoSalon = tipoSalon.strip()
112        print(f"Consultando reservas para el salón: '{tipoSalon}'")
113
114         # Crear una instancia de la clase Connectionbd y obtener las reservas para el salón seleccionado
115        conexion_bd = Connectionbd(self.db_path)  # Suponiendo que self.db_path es la ubicación de la base de datos
116        reservas = conexion_bd.get_reservasSalon(tipoSalon)
117        print(f"Reservas encontradas: {len(reservas)}")
118
119        # Comprobamos si no se encontraron reservas
120        if not reservas:
121            print(f"No se encontraron reservas para el salón: {tipoSalon}")
122            return  # No se hace nada si no hay resultados
123
124        # Configurar el número de columnas de la tabla a 4 (para las 4 columnas que vamos a mostrar)
125        self.ui.tableWidget.setColumnCount(5)#una columna de + para ocultar id
126
127        # Agregar cada reserva a la tabla
128        for row_number, row_data in enumerate(reservas):
129            self.ui.tableWidget.insertRow(row_number)
130          
131            
132
133              # Extraer los datos de la reserva
134            reserva_id = row_data [0] # Si tienes un ID real, usa ese valor aquí
135            fecha = row_data[1]  # Suponiendo que 'fecha' es la primera columna en la consulta
136            persona = row_data[2]  # Suponiendo que 'persona' es la segunda columna
137            telefono = row_data[3]  # Suponiendo que 'telefono' es la tercera columna
138            tipo_reserva_id = row_data[4]  # Suponiendo que 'tipo_reserva_id' es la cuarta columna
139
140            # Insertar el valor del reserva_id en la primera columna (ahora visible)
141            self.ui.tableWidget.setItem(row_number, 0, QTableWidgetItem(str(reserva_id)))
142
143            # Insertar el valor de la fecha en la segunda columna
144            self.ui.tableWidget.setItem(row_number, 1, QTableWidgetItem(str(fecha)))
145            # Insertar el valor de la persona en la tercera columna
146            self.ui.tableWidget.setItem(row_number, 2, QTableWidgetItem(str(persona)))
147            # Insertar el valor del teléfono en la cuarta columna
148            self.ui.tableWidget.setItem(row_number, 3, QTableWidgetItem(str(telefono)))
149            # Insertar el valor del tipo de reserva en la quinta columna
150            self.ui.tableWidget.setItem(row_number, 4, QTableWidgetItem(str(tipo_reserva_id)))   
151            
152        # Configurar los encabezados de las columnas (solo una vez)
153        self.ui.tableWidget.setHorizontalHeaderLabels(["ID","Fecha", "Persona", "Teléfono", "Tipo Reserva"])
154
155        # Ocultar la columna del ID
156       # self.ui.tableWidget.setColumnHidden(0, True)
157
158        # Ajustar el tamaño de las columnas para que se ajusten al contenido
159        self.ui.tableWidget.resizeColumnsToContents()
160
161            
162        # Forzar actualización de la tabla
163       # self.ui.tableWidget.repaint() 
164
165    def modificar_reserva(self):
166        """
167        Abre la interfaz 4 (ModificarReservaControlador) al hacer clic en el botón "Modificar Reserva".
168        Hay que seleccionar un dato de la fila que se desea modificar.
169     """
170       
171         # Obtener la fila seleccionada
172        row = self.ui.tableWidget.currentRow()
173        if row == -1:
174            QMessageBox.warning(self, "Advertencia", "Por favor, selecciona una reserva para modificar.")
175            return
176
177         # Obtener el reserva_id desde la fila seleccionada (este es el valor oculto en la tabla)
178        reserva_id = self.ui.tableWidget.item(row, 0) 
179        if not reserva_id:
180            QMessageBox.critical(self, "Error", "No se pudo obtener el ID de la reserva seleccionada.")
181            return
182        reserva_id=reserva_id.text()
183        print(f"ID de la reserva seleccionada: {reserva_id}")
184
185        # Ahora obtenemos todos los datos completos de la reserva usando reserva_id
186        try:
187            conexion = sqlite3.connect(self.db_path)
188            cursor = conexion.cursor()
189
190            cursor.execute("""
191                SELECT persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, ocupacion, jornadas, habitaciones
192                FROM reservas
193                WHERE reserva_id = ?
194            """, (reserva_id,))
195
196            datos_reserva = cursor.fetchone()
197            #conexion.close()
198
199            if  datos_reserva:
200                 # Ahora pasamos los datos completos a la ventana de modificación
201                persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, ocupacion, jornadas, habitaciones = datos_reserva
202            else:
203                QMessageBox.warning(self, "Error", "No se encontró la reserva con ese ID.")
204                return
205
206           
207            # Crear una instancia de la ventana de modificación y pasarle los datos
208            datos_completos = {
209                "persona": persona,
210                "telefono": telefono,
211                "fecha": fecha,
212                "tipo_reserva_id": tipo_reserva_id,
213                "tipo_cocina_id": tipo_cocina_id,
214                "ocupacion": ocupacion,
215                "jornadas": jornadas,
216                "habitaciones": habitaciones
217            }
218
219            self.ventana4 = ModificarReservaControlador(datos_reserva=datos_completos, reserva_id=reserva_id)
220            self.ventana4.show()
221
222        except sqlite3.Error as e:
223            QMessageBox.critical(self, "Error", f"No se pudo cargar los datos de la reserva: {e}")
224
225    def obtener_datos_reserva(self, reserva_id):
226        """
227        Obtiene los datos completos de una reserva usando su ID.
228        """
229        try:
230            conexion = sqlite3.connect(self.db_path)
231            cursor = conexion.cursor()
232
233            cursor.execute("""
234                SELECT persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, ocupacion, jornadas, habitaciones
235                FROM reservas
236                WHERE reserva_id = ?
237                ORDER BY fecha DESC
238            """, (reserva_id,))
239
240            # Obtener los resultados
241            datos_reserva = cursor.fetchone()
242
243            conexion.close()
244
245            # Si no se encontró la reserva, devolver None
246            if not datos_reserva:
247                return None
248
249            return datos_reserva
250
251        except sqlite3.Error as e:
252            QMessageBox.critical(self, "Error", f"No se pudo obtener los datos de la reserva: {e}")
253            return None

Interfaz 2, en la que se selecciona el tipo de salón que buscamos para reservas y celebrar un evento, si no se selecciona ningún tipo de salón no debe poder acceder a la interfaz 3

Métodos: cargarSalones():carga los salones que hay en la base de datos abrirReserva(): abrir la ventana 3 cargarReservas(tipoSalon): carga reservas asociadas a cada tipo de salon seleccionado

MostrarReservasControlador(parent=None)
31    def __init__(self, parent=None):
32
33        """
34        Inicializa la interfaz y configura la conexion con la base de datos
35        cargando los tipos de salones y las reservas que tienen
36        """
37        
38        super().__init__(parent)
39        self.ui = Ui_nlgReservas()
40        self.ui.setupUi(self)
41
42        # Conectar los eventos con las funciones
43        self.ui.pushButtonReserva.clicked.connect(self.abrirReserva)
44        self.ui.comboBoxSalones.currentTextChanged.connect(self.cargarReservas)
45        self.ui.pushButtonModificar.clicked.connect(self.modificar_reserva)
46
47        # Iniciar la conexión con la BBDD
48        self.db_path = "Conexion_BBDD/reservasHotel.sql"
49        self.dbManager = Connectionbd(self.db_path)
50       
51
52        # Cargar los salones desde la base de datos
53        self.cargarSalones()
54
55        # Establecer el valor por defecto en el comboBox
56        self.ui.comboBoxSalones.setCurrentIndex(0)  # Establece el primer ítem como seleccionado

Inicializa la interfaz y configura la conexion con la base de datos cargando los tipos de salones y las reservas que tienen

ui
db_path
dbManager
def cargarSalones(self):
58    def cargarSalones(self):
59        """
60        carga los salones disponibles en la base de datos y añade al comboBox
61        """
62        
63        # Realizar la consulta a la base de datos para obtener los salones
64        salones= self.dbManager.get_salones()
65        
66        # Limpiar el comboBox antes de agregar nuevos datos
67        self.ui.comboBoxSalones.clear()
68        
69        # Agregar un valor por defecto al comboBox
70        self.ui.comboBoxSalones.addItem("Selecciona un salón")
71        
72        # Agregar los salones obtenidos de la base de datos
73        for salon_id, salon_nombre in salones:
74            self.ui.comboBoxSalones.addItem(salon_nombre, salon_id)

carga los salones disponibles en la base de datos y añade al comboBox

def abrirReserva(self):
77    def abrirReserva(self):
78        """
79        Abrir la interfaz de reserva (Ventana 3) pero verifica antes que se haya seleccionado
80        un salón de los que hay en la base de datos
81        """
82        # Verificar que haya 1 salón seleccionado
83        salon_id = self.ui.comboBoxSalones.currentData()  # Obtiene el salon_id, no solo el texto
84        tipoSalon = self.ui.comboBoxSalones.currentText()
85
86        if tipoSalon == "Selecciona un salón":
87            QMessageBox.warning(self, 
88                "Advertencia",
89                "Debes seleccionar un salón para la reserva."
90            )
91            return  # Salir si no hay salón seleccionado
92
93        # Para abrir la ventana de reserva y pasar el el salon_id
94        self.ventana3=ReservarControlador(salon_id=salon_id)
95        self.ventana3.show()

Abrir la interfaz de reserva (Ventana 3) pero verifica antes que se haya seleccionado un salón de los que hay en la base de datos

def cargarReservas(self, tipoSalon):
 98    def cargarReservas(self, tipoSalon):
 99        """
100        Carga las reservas que hay en la base de datos asociadas a cada tipo de salon
101        """
102       
103        # Vaciar la tabla para cargar los nuevos datos
104        self.ui.tableWidget.setRowCount(0)
105
106        # Verificar que no se cargue nada si el usuario no selecciona un salón válido
107        if tipoSalon == "Selecciona un salón":
108            return
109
110        # Limpiar espacios en blanco extra antes de hacer la consulta
111        tipoSalon = tipoSalon.strip()
112        print(f"Consultando reservas para el salón: '{tipoSalon}'")
113
114         # Crear una instancia de la clase Connectionbd y obtener las reservas para el salón seleccionado
115        conexion_bd = Connectionbd(self.db_path)  # Suponiendo que self.db_path es la ubicación de la base de datos
116        reservas = conexion_bd.get_reservasSalon(tipoSalon)
117        print(f"Reservas encontradas: {len(reservas)}")
118
119        # Comprobamos si no se encontraron reservas
120        if not reservas:
121            print(f"No se encontraron reservas para el salón: {tipoSalon}")
122            return  # No se hace nada si no hay resultados
123
124        # Configurar el número de columnas de la tabla a 4 (para las 4 columnas que vamos a mostrar)
125        self.ui.tableWidget.setColumnCount(5)#una columna de + para ocultar id
126
127        # Agregar cada reserva a la tabla
128        for row_number, row_data in enumerate(reservas):
129            self.ui.tableWidget.insertRow(row_number)
130          
131            
132
133              # Extraer los datos de la reserva
134            reserva_id = row_data [0] # Si tienes un ID real, usa ese valor aquí
135            fecha = row_data[1]  # Suponiendo que 'fecha' es la primera columna en la consulta
136            persona = row_data[2]  # Suponiendo que 'persona' es la segunda columna
137            telefono = row_data[3]  # Suponiendo que 'telefono' es la tercera columna
138            tipo_reserva_id = row_data[4]  # Suponiendo que 'tipo_reserva_id' es la cuarta columna
139
140            # Insertar el valor del reserva_id en la primera columna (ahora visible)
141            self.ui.tableWidget.setItem(row_number, 0, QTableWidgetItem(str(reserva_id)))
142
143            # Insertar el valor de la fecha en la segunda columna
144            self.ui.tableWidget.setItem(row_number, 1, QTableWidgetItem(str(fecha)))
145            # Insertar el valor de la persona en la tercera columna
146            self.ui.tableWidget.setItem(row_number, 2, QTableWidgetItem(str(persona)))
147            # Insertar el valor del teléfono en la cuarta columna
148            self.ui.tableWidget.setItem(row_number, 3, QTableWidgetItem(str(telefono)))
149            # Insertar el valor del tipo de reserva en la quinta columna
150            self.ui.tableWidget.setItem(row_number, 4, QTableWidgetItem(str(tipo_reserva_id)))   
151            
152        # Configurar los encabezados de las columnas (solo una vez)
153        self.ui.tableWidget.setHorizontalHeaderLabels(["ID","Fecha", "Persona", "Teléfono", "Tipo Reserva"])
154
155        # Ocultar la columna del ID
156       # self.ui.tableWidget.setColumnHidden(0, True)
157
158        # Ajustar el tamaño de las columnas para que se ajusten al contenido
159        self.ui.tableWidget.resizeColumnsToContents()
160
161            
162        # Forzar actualización de la tabla

Carga las reservas que hay en la base de datos asociadas a cada tipo de salon

def modificar_reserva(self):
165    def modificar_reserva(self):
166        """
167        Abre la interfaz 4 (ModificarReservaControlador) al hacer clic en el botón "Modificar Reserva".
168        Hay que seleccionar un dato de la fila que se desea modificar.
169     """
170       
171         # Obtener la fila seleccionada
172        row = self.ui.tableWidget.currentRow()
173        if row == -1:
174            QMessageBox.warning(self, "Advertencia", "Por favor, selecciona una reserva para modificar.")
175            return
176
177         # Obtener el reserva_id desde la fila seleccionada (este es el valor oculto en la tabla)
178        reserva_id = self.ui.tableWidget.item(row, 0) 
179        if not reserva_id:
180            QMessageBox.critical(self, "Error", "No se pudo obtener el ID de la reserva seleccionada.")
181            return
182        reserva_id=reserva_id.text()
183        print(f"ID de la reserva seleccionada: {reserva_id}")
184
185        # Ahora obtenemos todos los datos completos de la reserva usando reserva_id
186        try:
187            conexion = sqlite3.connect(self.db_path)
188            cursor = conexion.cursor()
189
190            cursor.execute("""
191                SELECT persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, ocupacion, jornadas, habitaciones
192                FROM reservas
193                WHERE reserva_id = ?
194            """, (reserva_id,))
195
196            datos_reserva = cursor.fetchone()
197            #conexion.close()
198
199            if  datos_reserva:
200                 # Ahora pasamos los datos completos a la ventana de modificación
201                persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, ocupacion, jornadas, habitaciones = datos_reserva
202            else:
203                QMessageBox.warning(self, "Error", "No se encontró la reserva con ese ID.")
204                return
205
206           
207            # Crear una instancia de la ventana de modificación y pasarle los datos
208            datos_completos = {
209                "persona": persona,
210                "telefono": telefono,
211                "fecha": fecha,
212                "tipo_reserva_id": tipo_reserva_id,
213                "tipo_cocina_id": tipo_cocina_id,
214                "ocupacion": ocupacion,
215                "jornadas": jornadas,
216                "habitaciones": habitaciones
217            }
218
219            self.ventana4 = ModificarReservaControlador(datos_reserva=datos_completos, reserva_id=reserva_id)
220            self.ventana4.show()
221
222        except sqlite3.Error as e:
223            QMessageBox.critical(self, "Error", f"No se pudo cargar los datos de la reserva: {e}")

Abre la interfaz 4 (ModificarReservaControlador) al hacer clic en el botón "Modificar Reserva". Hay que seleccionar un dato de la fila que se desea modificar.

def obtener_datos_reserva(self, reserva_id):
225    def obtener_datos_reserva(self, reserva_id):
226        """
227        Obtiene los datos completos de una reserva usando su ID.
228        """
229        try:
230            conexion = sqlite3.connect(self.db_path)
231            cursor = conexion.cursor()
232
233            cursor.execute("""
234                SELECT persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, ocupacion, jornadas, habitaciones
235                FROM reservas
236                WHERE reserva_id = ?
237                ORDER BY fecha DESC
238            """, (reserva_id,))
239
240            # Obtener los resultados
241            datos_reserva = cursor.fetchone()
242
243            conexion.close()
244
245            # Si no se encontró la reserva, devolver None
246            if not datos_reserva:
247                return None
248
249            return datos_reserva
250
251        except sqlite3.Error as e:
252            QMessageBox.critical(self, "Error", f"No se pudo obtener los datos de la reserva: {e}")
253            return None

Obtiene los datos completos de una reserva usando su ID.

staticMetaObject = PySide6.QtCore.QMetaObject("MostrarReservasControlador" inherits "QMainWindow": )