DI_U3.Controladores.reservarControlador

  1import sys
  2import os
  3
  4sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
  5
  6from PySide6.QtWidgets import QMainWindow, QMessageBox,QInputDialog# type: ignore
  7from PySide6.QtWidgets import QApplication # type: ignore
  8from PySide6.QtCore import Qt, QDate,QTimer # type: ignore
  9from Vistas.reservar import Ui_nlgConfirmarReserva
 10from Conexion_BBDD.connectionBBDD import Connectionbd 
 11#from Controladores.modificarReservaControlador import ModificarReservaControlador
 12import sqlite3
 13
 14
 15class ReservarControlador(QMainWindow):
 16    """
 17    Interfaz 3 para gestionar las reservas
 18    Permite dar de alta una reserva, 
 19    asignado automaticamente al crear una reserva un localizador ID, 
 20    todo ello guardado en la base de datos
 21    """
 22    
 23    def __init__(self,salon_id=None,parent=None):
 24        """
 25        Inicializa la gestión de reservas
 26        Args: 
 27            salon_id (int, optional): ID del salon asociado en la base de datos, por defecto es None
 28            parent(QWidget, optional): Widget padre de la ventana, por defecto es None
 29        """
 30        super().__init__(parent)
 31        self.ui = Ui_nlgConfirmarReserva()
 32        self.ui.setupUi(self)
 33
 34        #almacenar el salon_id recibido
 35        self.salon_id=salon_id
 36        
 37        # Inicializar la base de datos
 38        self.db_path = 'Conexion_BBDD/reservasHotel.sql'
 39        self.dbManager = Connectionbd(self.db_path)
 40
 41        # Conectar botones a funciones
 42        self.ui.ButtonConfirmarReserva.clicked.connect(self.confirmar_reserva)
 43        self.ui.pushButtonVolver.clicked.connect(self.volver)
 44        #self.ui.pushButtonModificarReserva.clicked.connect(self.modificar_reserva)
 45
 46        # Cargar los tipos en los comboboxes
 47        self.cargar_tipos_reserva()
 48        self.cargar_tipos_cocina()
 49    
 50        # Configuración predeterminada de fecha
 51        self.ui.dateEditReserva.setDate(QDate.currentDate())  
 52        self.ui.dateEditReserva.setMinimumDate(QDate.currentDate()) 
 53        self.ui.dateEditReserva.setDisplayFormat("dd-MM-yyyy")
 54        self.ui.dateEditReserva.setFocusPolicy(Qt.StrongFocus)  
 55        self.ui.dateEditReserva.setCalendarPopup(True)  # Muestra el calendario
 56
 57        # Ocultar campos por defecto
 58        self.ui.labelNumJornadas.setVisible(False)
 59        self.ui.spinBoxNumHab.setVisible(False)
 60        self.ui.labelHabitacion.setVisible(False)
 61        self.ui.checkBoxHabitacion.setVisible(False)
 62
 63        # Conectar señales
 64        self.ui.comboBoxTipoReserva.currentTextChanged.connect(self.on_tipo_reserva_changed)
 65
 66   
 67    def cargar_tipos_reserva(self):
 68        """
 69        Carga los tipos de reserva desde la base de datos y los muestra en el ComboBox
 70        """
 71        try:
 72            conexion = sqlite3.connect(self.db_path)
 73            cursor = conexion.cursor()
 74            cursor.execute("SELECT tipo_reserva_id, nombre FROM tipos_reservas")  # Asegúrate de que la tabla sea correcta
 75            tipos_reserva = cursor.fetchall()
 76
 77            #self.ui.comboBoxTipoReserva.clear()  # Limpiar el comboBox antes de llenarlo
 78            for tipo_reserva_id, nombre in tipos_reserva:
 79                self.ui.comboBoxTipoReserva.addItem(nombre, tipo_reserva_id)
 80
 81            conexion.close()
 82        except sqlite3.Error as e:
 83            QMessageBox.critical(self, "Error", f"No se pudo cargar los tipos de reserva: {e}")
 84
 85    def cargar_tipos_cocina(self):
 86        """
 87        Carga los tipos de cocina desde la base de datos y los muestra en el ComboBox
 88        """
 89        try:         
 90            conexion = sqlite3.connect(self.db_path)
 91            cursor = conexion.cursor()
 92            cursor.execute("SELECT tipo_cocina_id, nombre FROM tipos_cocina")
 93            tipos_cocina = cursor.fetchall()
 94
 95            for tipo_cocina_id, nombre in tipos_cocina:
 96                self.ui.comboBoxTipoCocina.addItem(nombre, tipo_cocina_id)
 97
 98            conexion.close()
 99        except sqlite3.Error as e:
100            QMessageBox.critical(self, "Error", f"No se pudo cargar los tipos de cocina: {e}")
101
102    def on_tipo_reserva_changed(self, text):
103        """
104        Muestra u oculta campos adicionales según el tipo de reserva->nºjornadas y habitaciones
105        Args:
106            text(str): texto del tipo de reserva seleccionado
107        """
108        if text == "Congreso":
109            self.ui.labelNumJornadas.setVisible(True)
110            self.ui.spinBoxNumHab.setVisible(True)
111            self.ui.labelHabitacion.setVisible(True)
112            self.ui.checkBoxHabitacion.setVisible(True)
113        else:
114            self.ui.labelNumJornadas.setVisible(False)
115            self.ui.spinBoxNumHab.setVisible(False)
116            self.ui.labelHabitacion.setVisible(False)
117            self.ui.checkBoxHabitacion.setVisible(False)
118
119    def confirmar_reserva(self):
120        """
121        Guarda la reserva en la base de datos con los datos insertados 
122        por el usuario
123        """
124        try:
125            # Obtener los datos del formulario
126            persona = self.ui.lineEditNombrePersona.text()
127            telefono = self.ui.lineEditTlPersona.text()
128            fecha = self.ui.dateEditReserva.date().toString("dd-MM-yyyy")
129            salon_id = self.ui.comboBoxTipoReserva.currentData()
130            tipo_cocina_id = self.ui.comboBoxTipoCocina.currentData()
131            ocupacion = self.ui.lineEdit_2.text()
132            tipo_reserva_id = self.ui.comboBoxTipoReserva.currentData()
133
134            # Obtener valores de jornadas y habitaciones
135            jornadas = self.ui.spinBoxNumHab.value() if self.ui.labelNumJornadas.isVisible() else 0
136            habitaciones = 1 if self.ui.checkBoxHabitacion.isChecked() else 0
137
138            # Validaciones
139            if not persona or not telefono or not salon_id or not tipo_cocina_id or not ocupacion:
140                QMessageBox.warning(self, "Error", "Todos los campos deben estar completos.")
141                return
142
143            if not ocupacion.isdigit():
144                QMessageBox.warning(self, "Error", "El número de personas debe ser un valor numérico.")
145                return
146
147            # Conectar a la base de datos y guardar la reserva
148            conexion = sqlite3.connect(self.db_path)
149            cursor = conexion.cursor()
150            cursor.execute("""
151                INSERT INTO reservas (salon_id, persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, ocupacion, jornadas, habitaciones)
152                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
153            """, (salon_id, persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, int(ocupacion), jornadas, habitaciones))
154
155            conexion.commit()
156
157            # Obtener el ID de la reserva recién insertada
158            reserva_id = cursor.lastrowid
159            self.ui.lineEdit_2.setText(str(reserva_id))  # Establecer el ID de la reserva en el QLineEdit
160
161            self.ui.lineEdit_2.setReadOnly(True) #para que no pueda escribir sobre campo de id al registrarse
162
163            QMessageBox.information(self, "Éxito", f"Reserva confirmada. Su localizador es {reserva_id}.")
164        except sqlite3.Error as e:
165            QMessageBox.critical(self, "Error", f"No se pudo guardar la reserva: {e}")
166        finally:
167            conexion.close()
168
169    def volver(self):
170        """
171        Vuelve a la interfaz anterior (2)
172        """
173        self.close()  # Cierra la interfaz actual y vuelve a la anterior
174       
175    """
176    def modificar_reserva(self):
177        
178        Abre la interfaz 4 (ModificarReservaControlador) al hacer clic en el botón "Modificar Reserva".
179        Pide el ID de la reserva que se desea modificar.
180     
181        reserva_id , ok= QInputDialog.getInt(self, "Modificar Reserva", "Introduce el número de localizador:", 
182                                             minValue=1)
183     
184     
185        if ok:  # Si el usuario hace clic en OK
186                # Verificar que el ID de reserva existe en la base de datos
187            if self.verificar_reserva_existe(reserva_id):
188                # Si la reserva existe, abrir la interfaz de modificación
189                self.modificar_ventana = ModificarReservaControlador(reserva_id, self)
190                self.modificar_ventana.show()  # Mostrar la interfaz de modificación
191              
192            else:
193                # Si la reserva no existe, mostrar un mensaje de error
194                QMessageBox.warning(self, "Error", "El número de localizador no existe.")"""
195    
196    def verificar_reserva_existe(self, reserva_id):
197        """
198        Verifica si el número de localizador existe en la base de datos.
199        """
200        try:
201            conexion = sqlite3.connect(self.db_path)
202            cursor = conexion.cursor()
203            cursor.execute("SELECT COUNT(*) FROM reservas WHERE reserva_id = ?", (reserva_id,))
204            existe = cursor.fetchone()[0] > 0
205            conexion.close()
206            return existe
207        except sqlite3.Error as e:
208            QMessageBox.critical(self, "Error", f"Error al verificar el localizador: {e}")
209            return False
210
211
212if __name__ == "__main__":
213    import sys
214    app = QApplication([])
215    ventana = ReservarControlador()
216    ventana.show()  # Muestra la ventana
217    app.exec()  # Inicia el ciclo de eventos
class ReservarControlador(PySide6.QtWidgets.QMainWindow):
 16class ReservarControlador(QMainWindow):
 17    """
 18    Interfaz 3 para gestionar las reservas
 19    Permite dar de alta una reserva, 
 20    asignado automaticamente al crear una reserva un localizador ID, 
 21    todo ello guardado en la base de datos
 22    """
 23    
 24    def __init__(self,salon_id=None,parent=None):
 25        """
 26        Inicializa la gestión de reservas
 27        Args: 
 28            salon_id (int, optional): ID del salon asociado en la base de datos, por defecto es None
 29            parent(QWidget, optional): Widget padre de la ventana, por defecto es None
 30        """
 31        super().__init__(parent)
 32        self.ui = Ui_nlgConfirmarReserva()
 33        self.ui.setupUi(self)
 34
 35        #almacenar el salon_id recibido
 36        self.salon_id=salon_id
 37        
 38        # Inicializar la base de datos
 39        self.db_path = 'Conexion_BBDD/reservasHotel.sql'
 40        self.dbManager = Connectionbd(self.db_path)
 41
 42        # Conectar botones a funciones
 43        self.ui.ButtonConfirmarReserva.clicked.connect(self.confirmar_reserva)
 44        self.ui.pushButtonVolver.clicked.connect(self.volver)
 45        #self.ui.pushButtonModificarReserva.clicked.connect(self.modificar_reserva)
 46
 47        # Cargar los tipos en los comboboxes
 48        self.cargar_tipos_reserva()
 49        self.cargar_tipos_cocina()
 50    
 51        # Configuración predeterminada de fecha
 52        self.ui.dateEditReserva.setDate(QDate.currentDate())  
 53        self.ui.dateEditReserva.setMinimumDate(QDate.currentDate()) 
 54        self.ui.dateEditReserva.setDisplayFormat("dd-MM-yyyy")
 55        self.ui.dateEditReserva.setFocusPolicy(Qt.StrongFocus)  
 56        self.ui.dateEditReserva.setCalendarPopup(True)  # Muestra el calendario
 57
 58        # Ocultar campos por defecto
 59        self.ui.labelNumJornadas.setVisible(False)
 60        self.ui.spinBoxNumHab.setVisible(False)
 61        self.ui.labelHabitacion.setVisible(False)
 62        self.ui.checkBoxHabitacion.setVisible(False)
 63
 64        # Conectar señales
 65        self.ui.comboBoxTipoReserva.currentTextChanged.connect(self.on_tipo_reserva_changed)
 66
 67   
 68    def cargar_tipos_reserva(self):
 69        """
 70        Carga los tipos de reserva desde la base de datos y los muestra en el ComboBox
 71        """
 72        try:
 73            conexion = sqlite3.connect(self.db_path)
 74            cursor = conexion.cursor()
 75            cursor.execute("SELECT tipo_reserva_id, nombre FROM tipos_reservas")  # Asegúrate de que la tabla sea correcta
 76            tipos_reserva = cursor.fetchall()
 77
 78            #self.ui.comboBoxTipoReserva.clear()  # Limpiar el comboBox antes de llenarlo
 79            for tipo_reserva_id, nombre in tipos_reserva:
 80                self.ui.comboBoxTipoReserva.addItem(nombre, tipo_reserva_id)
 81
 82            conexion.close()
 83        except sqlite3.Error as e:
 84            QMessageBox.critical(self, "Error", f"No se pudo cargar los tipos de reserva: {e}")
 85
 86    def cargar_tipos_cocina(self):
 87        """
 88        Carga los tipos de cocina desde la base de datos y los muestra en el ComboBox
 89        """
 90        try:         
 91            conexion = sqlite3.connect(self.db_path)
 92            cursor = conexion.cursor()
 93            cursor.execute("SELECT tipo_cocina_id, nombre FROM tipos_cocina")
 94            tipos_cocina = cursor.fetchall()
 95
 96            for tipo_cocina_id, nombre in tipos_cocina:
 97                self.ui.comboBoxTipoCocina.addItem(nombre, tipo_cocina_id)
 98
 99            conexion.close()
100        except sqlite3.Error as e:
101            QMessageBox.critical(self, "Error", f"No se pudo cargar los tipos de cocina: {e}")
102
103    def on_tipo_reserva_changed(self, text):
104        """
105        Muestra u oculta campos adicionales según el tipo de reserva->nºjornadas y habitaciones
106        Args:
107            text(str): texto del tipo de reserva seleccionado
108        """
109        if text == "Congreso":
110            self.ui.labelNumJornadas.setVisible(True)
111            self.ui.spinBoxNumHab.setVisible(True)
112            self.ui.labelHabitacion.setVisible(True)
113            self.ui.checkBoxHabitacion.setVisible(True)
114        else:
115            self.ui.labelNumJornadas.setVisible(False)
116            self.ui.spinBoxNumHab.setVisible(False)
117            self.ui.labelHabitacion.setVisible(False)
118            self.ui.checkBoxHabitacion.setVisible(False)
119
120    def confirmar_reserva(self):
121        """
122        Guarda la reserva en la base de datos con los datos insertados 
123        por el usuario
124        """
125        try:
126            # Obtener los datos del formulario
127            persona = self.ui.lineEditNombrePersona.text()
128            telefono = self.ui.lineEditTlPersona.text()
129            fecha = self.ui.dateEditReserva.date().toString("dd-MM-yyyy")
130            salon_id = self.ui.comboBoxTipoReserva.currentData()
131            tipo_cocina_id = self.ui.comboBoxTipoCocina.currentData()
132            ocupacion = self.ui.lineEdit_2.text()
133            tipo_reserva_id = self.ui.comboBoxTipoReserva.currentData()
134
135            # Obtener valores de jornadas y habitaciones
136            jornadas = self.ui.spinBoxNumHab.value() if self.ui.labelNumJornadas.isVisible() else 0
137            habitaciones = 1 if self.ui.checkBoxHabitacion.isChecked() else 0
138
139            # Validaciones
140            if not persona or not telefono or not salon_id or not tipo_cocina_id or not ocupacion:
141                QMessageBox.warning(self, "Error", "Todos los campos deben estar completos.")
142                return
143
144            if not ocupacion.isdigit():
145                QMessageBox.warning(self, "Error", "El número de personas debe ser un valor numérico.")
146                return
147
148            # Conectar a la base de datos y guardar la reserva
149            conexion = sqlite3.connect(self.db_path)
150            cursor = conexion.cursor()
151            cursor.execute("""
152                INSERT INTO reservas (salon_id, persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, ocupacion, jornadas, habitaciones)
153                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
154            """, (salon_id, persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, int(ocupacion), jornadas, habitaciones))
155
156            conexion.commit()
157
158            # Obtener el ID de la reserva recién insertada
159            reserva_id = cursor.lastrowid
160            self.ui.lineEdit_2.setText(str(reserva_id))  # Establecer el ID de la reserva en el QLineEdit
161
162            self.ui.lineEdit_2.setReadOnly(True) #para que no pueda escribir sobre campo de id al registrarse
163
164            QMessageBox.information(self, "Éxito", f"Reserva confirmada. Su localizador es {reserva_id}.")
165        except sqlite3.Error as e:
166            QMessageBox.critical(self, "Error", f"No se pudo guardar la reserva: {e}")
167        finally:
168            conexion.close()
169
170    def volver(self):
171        """
172        Vuelve a la interfaz anterior (2)
173        """
174        self.close()  # Cierra la interfaz actual y vuelve a la anterior
175       
176    """
177    def modificar_reserva(self):
178        
179        Abre la interfaz 4 (ModificarReservaControlador) al hacer clic en el botón "Modificar Reserva".
180        Pide el ID de la reserva que se desea modificar.
181     
182        reserva_id , ok= QInputDialog.getInt(self, "Modificar Reserva", "Introduce el número de localizador:", 
183                                             minValue=1)
184     
185     
186        if ok:  # Si el usuario hace clic en OK
187                # Verificar que el ID de reserva existe en la base de datos
188            if self.verificar_reserva_existe(reserva_id):
189                # Si la reserva existe, abrir la interfaz de modificación
190                self.modificar_ventana = ModificarReservaControlador(reserva_id, self)
191                self.modificar_ventana.show()  # Mostrar la interfaz de modificación
192              
193            else:
194                # Si la reserva no existe, mostrar un mensaje de error
195                QMessageBox.warning(self, "Error", "El número de localizador no existe.")"""
196    
197    def verificar_reserva_existe(self, reserva_id):
198        """
199        Verifica si el número de localizador existe en la base de datos.
200        """
201        try:
202            conexion = sqlite3.connect(self.db_path)
203            cursor = conexion.cursor()
204            cursor.execute("SELECT COUNT(*) FROM reservas WHERE reserva_id = ?", (reserva_id,))
205            existe = cursor.fetchone()[0] > 0
206            conexion.close()
207            return existe
208        except sqlite3.Error as e:
209            QMessageBox.critical(self, "Error", f"Error al verificar el localizador: {e}")
210            return False

Interfaz 3 para gestionar las reservas Permite dar de alta una reserva, asignado automaticamente al crear una reserva un localizador ID, todo ello guardado en la base de datos

ReservarControlador(salon_id=None, parent=None)
24    def __init__(self,salon_id=None,parent=None):
25        """
26        Inicializa la gestión de reservas
27        Args: 
28            salon_id (int, optional): ID del salon asociado en la base de datos, por defecto es None
29            parent(QWidget, optional): Widget padre de la ventana, por defecto es None
30        """
31        super().__init__(parent)
32        self.ui = Ui_nlgConfirmarReserva()
33        self.ui.setupUi(self)
34
35        #almacenar el salon_id recibido
36        self.salon_id=salon_id
37        
38        # Inicializar la base de datos
39        self.db_path = 'Conexion_BBDD/reservasHotel.sql'
40        self.dbManager = Connectionbd(self.db_path)
41
42        # Conectar botones a funciones
43        self.ui.ButtonConfirmarReserva.clicked.connect(self.confirmar_reserva)
44        self.ui.pushButtonVolver.clicked.connect(self.volver)
45        #self.ui.pushButtonModificarReserva.clicked.connect(self.modificar_reserva)
46
47        # Cargar los tipos en los comboboxes
48        self.cargar_tipos_reserva()
49        self.cargar_tipos_cocina()
50    
51        # Configuración predeterminada de fecha
52        self.ui.dateEditReserva.setDate(QDate.currentDate())  
53        self.ui.dateEditReserva.setMinimumDate(QDate.currentDate()) 
54        self.ui.dateEditReserva.setDisplayFormat("dd-MM-yyyy")
55        self.ui.dateEditReserva.setFocusPolicy(Qt.StrongFocus)  
56        self.ui.dateEditReserva.setCalendarPopup(True)  # Muestra el calendario
57
58        # Ocultar campos por defecto
59        self.ui.labelNumJornadas.setVisible(False)
60        self.ui.spinBoxNumHab.setVisible(False)
61        self.ui.labelHabitacion.setVisible(False)
62        self.ui.checkBoxHabitacion.setVisible(False)
63
64        # Conectar señales
65        self.ui.comboBoxTipoReserva.currentTextChanged.connect(self.on_tipo_reserva_changed)

Inicializa la gestión de reservas Args: salon_id (int, optional): ID del salon asociado en la base de datos, por defecto es None parent(QWidget, optional): Widget padre de la ventana, por defecto es None

ui
salon_id
db_path
dbManager
def cargar_tipos_reserva(self):
68    def cargar_tipos_reserva(self):
69        """
70        Carga los tipos de reserva desde la base de datos y los muestra en el ComboBox
71        """
72        try:
73            conexion = sqlite3.connect(self.db_path)
74            cursor = conexion.cursor()
75            cursor.execute("SELECT tipo_reserva_id, nombre FROM tipos_reservas")  # Asegúrate de que la tabla sea correcta
76            tipos_reserva = cursor.fetchall()
77
78            #self.ui.comboBoxTipoReserva.clear()  # Limpiar el comboBox antes de llenarlo
79            for tipo_reserva_id, nombre in tipos_reserva:
80                self.ui.comboBoxTipoReserva.addItem(nombre, tipo_reserva_id)
81
82            conexion.close()
83        except sqlite3.Error as e:
84            QMessageBox.critical(self, "Error", f"No se pudo cargar los tipos de reserva: {e}")

Carga los tipos de reserva desde la base de datos y los muestra en el ComboBox

def cargar_tipos_cocina(self):
 86    def cargar_tipos_cocina(self):
 87        """
 88        Carga los tipos de cocina desde la base de datos y los muestra en el ComboBox
 89        """
 90        try:         
 91            conexion = sqlite3.connect(self.db_path)
 92            cursor = conexion.cursor()
 93            cursor.execute("SELECT tipo_cocina_id, nombre FROM tipos_cocina")
 94            tipos_cocina = cursor.fetchall()
 95
 96            for tipo_cocina_id, nombre in tipos_cocina:
 97                self.ui.comboBoxTipoCocina.addItem(nombre, tipo_cocina_id)
 98
 99            conexion.close()
100        except sqlite3.Error as e:
101            QMessageBox.critical(self, "Error", f"No se pudo cargar los tipos de cocina: {e}")

Carga los tipos de cocina desde la base de datos y los muestra en el ComboBox

def on_tipo_reserva_changed(self, text):
103    def on_tipo_reserva_changed(self, text):
104        """
105        Muestra u oculta campos adicionales según el tipo de reserva->nºjornadas y habitaciones
106        Args:
107            text(str): texto del tipo de reserva seleccionado
108        """
109        if text == "Congreso":
110            self.ui.labelNumJornadas.setVisible(True)
111            self.ui.spinBoxNumHab.setVisible(True)
112            self.ui.labelHabitacion.setVisible(True)
113            self.ui.checkBoxHabitacion.setVisible(True)
114        else:
115            self.ui.labelNumJornadas.setVisible(False)
116            self.ui.spinBoxNumHab.setVisible(False)
117            self.ui.labelHabitacion.setVisible(False)
118            self.ui.checkBoxHabitacion.setVisible(False)

Muestra u oculta campos adicionales según el tipo de reserva->nºjornadas y habitaciones Args: text(str): texto del tipo de reserva seleccionado

def confirmar_reserva(self):
120    def confirmar_reserva(self):
121        """
122        Guarda la reserva en la base de datos con los datos insertados 
123        por el usuario
124        """
125        try:
126            # Obtener los datos del formulario
127            persona = self.ui.lineEditNombrePersona.text()
128            telefono = self.ui.lineEditTlPersona.text()
129            fecha = self.ui.dateEditReserva.date().toString("dd-MM-yyyy")
130            salon_id = self.ui.comboBoxTipoReserva.currentData()
131            tipo_cocina_id = self.ui.comboBoxTipoCocina.currentData()
132            ocupacion = self.ui.lineEdit_2.text()
133            tipo_reserva_id = self.ui.comboBoxTipoReserva.currentData()
134
135            # Obtener valores de jornadas y habitaciones
136            jornadas = self.ui.spinBoxNumHab.value() if self.ui.labelNumJornadas.isVisible() else 0
137            habitaciones = 1 if self.ui.checkBoxHabitacion.isChecked() else 0
138
139            # Validaciones
140            if not persona or not telefono or not salon_id or not tipo_cocina_id or not ocupacion:
141                QMessageBox.warning(self, "Error", "Todos los campos deben estar completos.")
142                return
143
144            if not ocupacion.isdigit():
145                QMessageBox.warning(self, "Error", "El número de personas debe ser un valor numérico.")
146                return
147
148            # Conectar a la base de datos y guardar la reserva
149            conexion = sqlite3.connect(self.db_path)
150            cursor = conexion.cursor()
151            cursor.execute("""
152                INSERT INTO reservas (salon_id, persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, ocupacion, jornadas, habitaciones)
153                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
154            """, (salon_id, persona, telefono, fecha, tipo_reserva_id, tipo_cocina_id, int(ocupacion), jornadas, habitaciones))
155
156            conexion.commit()
157
158            # Obtener el ID de la reserva recién insertada
159            reserva_id = cursor.lastrowid
160            self.ui.lineEdit_2.setText(str(reserva_id))  # Establecer el ID de la reserva en el QLineEdit
161
162            self.ui.lineEdit_2.setReadOnly(True) #para que no pueda escribir sobre campo de id al registrarse
163
164            QMessageBox.information(self, "Éxito", f"Reserva confirmada. Su localizador es {reserva_id}.")
165        except sqlite3.Error as e:
166            QMessageBox.critical(self, "Error", f"No se pudo guardar la reserva: {e}")
167        finally:
168            conexion.close()

Guarda la reserva en la base de datos con los datos insertados por el usuario

def volver(self):
170    def volver(self):
171        """
172        Vuelve a la interfaz anterior (2)
173        """
174        self.close()  # Cierra la interfaz actual y vuelve a la anterior

Vuelve a la interfaz anterior (2)

def verificar_reserva_existe(self, reserva_id):
197    def verificar_reserva_existe(self, reserva_id):
198        """
199        Verifica si el número de localizador existe en la base de datos.
200        """
201        try:
202            conexion = sqlite3.connect(self.db_path)
203            cursor = conexion.cursor()
204            cursor.execute("SELECT COUNT(*) FROM reservas WHERE reserva_id = ?", (reserva_id,))
205            existe = cursor.fetchone()[0] > 0
206            conexion.close()
207            return existe
208        except sqlite3.Error as e:
209            QMessageBox.critical(self, "Error", f"Error al verificar el localizador: {e}")
210            return False

Verifica si el número de localizador existe en la base de datos.

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