def test_elimina_prenotazione_by_id(self):
self.controller = ControlloreListaPrenotazioni()
self.prenotazione = Prenotazione("Carlo", "Gissi", "AA", "Calcio",
"21-12-2021", "10:00")
self.controller.aggiungi_prenotazione(self.prenotazione)
self.controller.rimuovi_dalla_lista(self.prenotazione)
self.assertEmpty(self.controller.get_lista_prenotazioni())
def __init__(self, data_selezionata, parent=None):
super(VistaListaPrenotazioni, self).__init__(parent)
self.controller = ControlloreListaPrenotazioni()
self.data_selezionata = data_selezionata
self.controlloreMov = ControlloreListaMovimenti()
self.controllorePre = ControlloreListaPrenotazioni()
self.showMaximized()
self.setWindowTitle("Prenotazioni del {}".format(data_selezionata))
h_layout = QHBoxLayout()
self.createTable()
self.list_view = self.tableWidget
h_layout.addWidget(self.list_view)
buttons_layout = QVBoxLayout()
buttons_layout.addStretch()
btn_disdici = QPushButton("Disdici")
btn_disdici.setStyleSheet(
"background-color: #f08080; font-size: 13px; font-weight: bold;")
btn_disdici.clicked.connect(self.elimina_prenotazione_click)
buttons_layout.addWidget(btn_disdici)
btn_modifica = QPushButton('Modifica')
btn_modifica.setStyleSheet(
"background-color: #00bfff; font-size: 13px; font-weight: bold;")
btn_modifica.clicked.connect(self.modifica_prenotazione_click)
buttons_layout.addWidget(btn_modifica)
btn_esci = QPushButton('Esci')
btn_esci.setStyleSheet(
"background-color: #66cdaa; font-size: 13px; font-weight: bold;")
btn_esci.clicked.connect(self.funz_esci)
buttons_layout.addStretch()
buttons_layout.addWidget(btn_esci)
h_layout.addLayout(buttons_layout)
self.setLayout(h_layout)
self.controller.save_data()
def __init__(self):
super(VistaListaPrenotazioni, self).__init__()
grid_layout = QGridLayout()
self.controller = ControlloreListaPrenotazioni()
self.list_view = QListView()
self.calendar = QCalendarWidget(self)
self.calendar.move(20, 20)
self.calendar.setGridVisible(True)
self.calendar.setMinimumDate(QDate(currentYear, currentMonth - 1, 1))
self.calendar.setMaximumDate(
QDate(currentYear, currentMonth + 1,
calendar.monthrange(currentYear, currentMonth)[1]))
self.calendar.setSelectedDate(QDate(currentYear, currentMonth, 1))
self.calendar.clicked.connect(self.printInfo)
buttons_layout = QVBoxLayout()
add_button = QPushButton("Aggiungi prenotazione")
add_button.clicked.connect(self.aggiungi_prenotazione)
buttons_layout.addWidget(add_button)
delete_button = QPushButton("Elimina prenotazione")
delete_button.clicked.connect(self.elimina_prenotazione)
buttons_layout.addWidget(delete_button)
grid_layout.addWidget(self.calendar, 0, 0)
grid_layout.addLayout(buttons_layout, 0, 1)
grid_layout.addWidget(self.list_view, 1, 0)
self.resize(600, 400)
self.setWindowTitle('Lista Prenotazioni')
self.setLayout(grid_layout)
class Prenotazione():
def __init__(self, nome, cognome, documento, campo, data, ora_inizio):
self.controllore = ControlloreListaPrenotazioni()
# id della prenotazione assegnato automaticamente
self.index = self.get_ultimo_id()
self.index +=1
self.id = self.index
self.nome = nome
self.cognome = cognome
self.documento = documento
self.campo = campo
self.data = data
self.ora_inizio = ora_inizio
# la durata è standard -> la fine viene calcolata automaticamente
self.ora_fine = self.calcola_ora_fine()
# ritorna l'id dell'ultima prenotazione
def get_ultimo_id(self):
if not self.controllore.get_lista_prenotazioni():
# se la lista è vuota allora la prenotazione è la prima
return 0
else:
indice = len(self.controllore.get_lista_prenotazioni())-1
prenotazione = self.controllore.get_prenotazione_by_index(indice)
id = prenotazione.id
return id
# calcola l'ora di fine di una prenotazione
def calcola_ora_fine(self):
appoggio = self.ora_inizio.split(":")
ora = int(appoggio[0])
minuto = int(appoggio[1])
minuti = minuto + 30
if minuti == 60:
minuti = "00"
ora = ora + 2
self.ora_fine = "{}:{}".format(ora, minuti)
return self.ora_fine
else:
ora = ora + 1
self.ora_fine = "{}:{}".format(ora, minuti)
return self.ora_fine
# ritorna il prezzo dei campi per poter poi generare i movimenti di cassa
def prezzi_campi(self):
if self.campo.tipo == "Calcio":
prezzo = 80.00
return prezzo
elif self.campo.tipo == "Calcetto":
prezzo = 50.00
return prezzo
else:
prezzo = 40.00
return prezzo
class VistaListaPrenotazioni(QWidget):
def __init__(self, parent=None):
super(VistaListaPrenotazioni, self).__init__(parent)
self.controller = ControlloreListaPrenotazioni()
h_layout = QHBoxLayout()
self.list_view = QListView()
self.update_ui()
h_layout.addWidget(self.list_view)
buttons_layout = QVBoxLayout()
open_button = QPushButton('Apri')
open_button.clicked.connect(self.show_selected_info)
buttons_layout.addWidget(open_button)
new_button = QPushButton("Nuovo")
new_button.clicked.connect(self.show_new_prenotazione)
buttons_layout.addWidget(new_button)
buttons_layout.addStretch()
h_layout.addLayout(buttons_layout)
self.setLayout(h_layout)
self.resize(600, 300)
self.setWindowTitle('Lista Prenotazioni')
def update_ui(self):
self.listview_model = QStandardItemModel(self.list_view)
for prenotazione in self.controller.get_lista_delle_prenotazioni():
item = QStandardItem()
item.setText(prenotazione.cliente.cognome + " " +
prenotazione.cliente.nome)
item.setEditable(False)
font = item.font()
font.setPointSize(18)
item.setFont(font)
self.listview_model.appendRow(item)
self.list_view.setModel(self.listview_model)
def show_selected_info(self):
if (len(self.list_view.selectedIndexes()) > 0):
selected = self.list_view.selectedIndexes()[0].row()
prenotazione_selezionata = self.controller.get_prenotazione_by_index(
selected)
self.vista_prenotazione = VistaPrenotazione(
prenotazione_selezionata,
self.controller.elimina_prenotazione_by_id, self.update_ui)
self.vista_prenotazione.show()
def show_new_prenotazione(self):
self.vista_inserisci_prenotazione = VistaInserisciPrenotazione(
self.controller, self.update_ui)
self.vista_inserisci_prenotazione.show()
pass
def closeEvent(self, event):
self.controller.save_data()
def __init__(self, prenotazione_selezionata, controller, callback):
super(VistaModificaPrenotazione, self).__init__()
self.p = prenotazione_selezionata
self.prenotazione_sel = ControllorePrenotazione(prenotazione_selezionata)
self.controller = controller
self.callback = callback
self.info = {}
self.info = {}
self.c = ControlloreListaPrenotazioni()
self.combo_ora = QComboBox()
self.v_layout = QVBoxLayout()
self.setFixedSize(300, 500)
self.get_form_entry(self.prenotazione_sel.get_nome(),"Nome cliente")
self.get_form_entry(self.prenotazione_sel.get_cognome(),"Cognome cliente")
self.get_form_entry(self.prenotazione_sel.get_documento(),"Documento")
self.get_form_entry(self.prenotazione_sel.get_campo_tipo(),"Tipo campo")
self.numero = QLabel("Numero Campo")
self.v_layout.addWidget(self.numero)
self.radio()
print(QDate.currentDate())
self.data_label = QLabel("Data")
self.v_layout.addWidget(self.data_label)
self.btn_data = QPushButton("Inserisci data")
self.btn_data.clicked.connect(self.visualizza_calendario)
self.v_layout.addWidget(self.btn_data)
self.lista_ore = ["10:00", "10:30", "11:00", "11:30", "12:00", "12:30", "13:00", "13:30", "14:00",
"14:30", "15:00", "15:30", "16:00", "16:30", "17:00", "17:30", "18:00", "18:30",
"19:00", "19:30", "20:00", "20:30", "21:00", "21:30", ]
self.get_combo(self.lista_ore)
self.v_layout.addItem(QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding))
btn_ok = QPushButton("OK")
btn_ok.setStyleSheet("background-color: #90ee90; font-size: 15px; font-weight: bold;")
btn_ok.setShortcut("Return")
btn_ok.clicked.connect(self.add_prenotazione)
self.v_layout.addWidget(btn_ok)
# creazione pulsante di annullamento dell'inserimento
btn_annulla = QPushButton("Annulla")
btn_annulla.setStyleSheet("background-color: #f08080; font-size: 15px; font-weight: bold;")
btn_annulla.setShortcut("Esc")
btn_annulla.clicked.connect(self.close)
self.v_layout.addWidget(btn_annulla)
self.setLayout(self.v_layout)
self.setWindowTitle("Modifica Prenotazione")
def __init__(self, nome, cognome, documento, campo, data, ora_inizio):
self.controllore = ControlloreListaPrenotazioni()
# id della prenotazione assegnato automaticamente
self.index = self.get_ultimo_id()
self.index +=1
self.id = self.index
self.nome = nome
self.cognome = cognome
self.documento = documento
self.campo = campo
self.data = data
self.ora_inizio = ora_inizio
# la durata è standard -> la fine viene calcolata automaticamente
self.ora_fine = self.calcola_ora_fine()
def __init__(self, parent=None):
super(VistaListaPrenotazioni, self).__init__(parent)
h_layout = QHBoxLayout()
self.controller = ControlloreListaPrenotazioni()
self.list_view = QListView()
self.update_ui()
h_layout.addWidget(self.list_view)
buttons_layout = QVBoxLayout()
open_button = QPushButton("Apri")
open_button.clicked.connect(self.show_selected_info)
buttons_layout.addWidget(open_button)
new_button = QPushButton("Nuova")
new_button.clicked.connect(self.show_new_prenotazione)
buttons_layout.addWidget(new_button)
buttons_layout.addStretch()
h_layout.addLayout(buttons_layout)
self.setLayout(h_layout)
self.resize(600, 300)
self.setWindowTitle('Lista Prenotazioni')
class TestControlloreListaPrenotazioni(TestCase):
# La prenotazione viene aggiunta correttamente
def test_aggiungi_prenotazione(self):
self.lista = ListaPrenotazioni()
self.prenotazione = Prenotazione("Carlo", "Gissi", "AA", "Calcio",
"21-12-2021", "10:00")
self.lista.aggiungi_prenotazione(self.prenotazione)
self.assertNotEmpty(self.lista)
# La prenotazione viene eliminata correttamente
def test_elimina_prenotazione_by_id(self):
self.controller = ControlloreListaPrenotazioni()
self.prenotazione = Prenotazione("Carlo", "Gissi", "AA", "Calcio",
"21-12-2021", "10:00")
self.controller.aggiungi_prenotazione(self.prenotazione)
self.controller.rimuovi_dalla_lista(self.prenotazione)
self.assertEmpty(self.controller.get_lista_prenotazioni())
def assertEmpty(self, obj):
self.assertFalse(obj)
def assertNotEmpty(self, obj):
self.assertTrue(obj)
def __init__(self, parent = None):
super().__init__(parent)
self.showMaximized()
self.Calendar()
self.controller = ControlloreListaPrenotazioni()
self.list_view = QListView()
self.update_ui()
self.h_layout = QHBoxLayout()
from home.views.VistaHome import VistaHome
self.setWindowTitle("Campo da {}".format(VistaHome().selezione_campo))
self.h_layout.addLayout(self.vbox)
self.setLayout(self.h_layout)
self.show()
class VistaListaPrenotazioni(QWidget):
global currentYear, currentMonth
currentMonth = datetime.now().month
currentYear = datetime.now().year
def __init__(self):
super(VistaListaPrenotazioni, self).__init__()
grid_layout = QGridLayout()
self.controller = ControlloreListaPrenotazioni()
self.list_view = QListView()
self.calendar = QCalendarWidget(self)
self.calendar.move(20, 20)
self.calendar.setGridVisible(True)
self.calendar.setMinimumDate(QDate(currentYear, currentMonth - 1, 1))
self.calendar.setMaximumDate(
QDate(currentYear, currentMonth + 1,
calendar.monthrange(currentYear, currentMonth)[1]))
self.calendar.setSelectedDate(QDate(currentYear, currentMonth, 1))
self.calendar.clicked.connect(self.printInfo)
buttons_layout = QVBoxLayout()
add_button = QPushButton("Aggiungi prenotazione")
add_button.clicked.connect(self.aggiungi_prenotazione)
buttons_layout.addWidget(add_button)
delete_button = QPushButton("Elimina prenotazione")
delete_button.clicked.connect(self.elimina_prenotazione)
buttons_layout.addWidget(delete_button)
grid_layout.addWidget(self.calendar, 0, 0)
grid_layout.addLayout(buttons_layout, 0, 1)
grid_layout.addWidget(self.list_view, 1, 0)
self.resize(600, 400)
self.setWindowTitle('Lista Prenotazioni')
self.setLayout(grid_layout)
def printInfo(self, qDate):
self.listview_model = QStandardItemModel(self.list_view)
item = QStandardItem()
fontstd = QFont("DejaVu Sans Mono", 10)
fontstd.setFamily('Monospace')
fontstd.setFixedPitch(True)
item.setFont(fontstd)
item.setText("{0:<15}{1:<12}{2:<10}{3}".format("Nome: ", "Telefono:",
"Persone:", "Orario:"))
item.setEditable(False)
font = item.font()
font.setPointSize(12)
item.setFont(font)
self.listview_model.appendRow(item)
for prenotazione in self.controller.get_prenotazioni_by_data(
datetime(qDate.year(), qDate.month(), qDate.day())):
item = QStandardItem()
fontstd = QFont("DejaVu Sans Mono", 10)
fontstd.setFamily('Monospace')
fontstd.setFixedPitch(True)
item.setFont(fontstd)
item.setText("{0:<15}{1:<12}{2:<10}{3}".format(
prenotazione.nome, prenotazione.telefono,
prenotazione.num_persone, prenotazione.data.hour))
item.setEditable(False)
font = item.font()
font.setPointSize(12)
item.setFont(font)
self.listview_model.appendRow(item)
self.list_view.setModel(self.listview_model)
def aggiungi_prenotazione(self):
self.vista_aggiungi_prenotazione = VistaPrenotazione(self.controller)
self.vista_aggiungi_prenotazione.show()
def elimina_prenotazione(self):
pass
class VistaListaPrenotazioni(QWidget):
def __init__(self, data_selezionata, parent=None):
super(VistaListaPrenotazioni, self).__init__(parent)
self.controller = ControlloreListaPrenotazioni()
self.data_selezionata = data_selezionata
self.controlloreMov = ControlloreListaMovimenti()
self.controllorePre = ControlloreListaPrenotazioni()
self.showMaximized()
self.setWindowTitle("Prenotazioni del {}".format(data_selezionata))
h_layout = QHBoxLayout()
self.createTable()
self.list_view = self.tableWidget
h_layout.addWidget(self.list_view)
buttons_layout = QVBoxLayout()
buttons_layout.addStretch()
btn_disdici = QPushButton("Disdici")
btn_disdici.setStyleSheet(
"background-color: #f08080; font-size: 13px; font-weight: bold;")
btn_disdici.clicked.connect(self.elimina_prenotazione_click)
buttons_layout.addWidget(btn_disdici)
btn_modifica = QPushButton('Modifica')
btn_modifica.setStyleSheet(
"background-color: #00bfff; font-size: 13px; font-weight: bold;")
btn_modifica.clicked.connect(self.modifica_prenotazione_click)
buttons_layout.addWidget(btn_modifica)
btn_esci = QPushButton('Esci')
btn_esci.setStyleSheet(
"background-color: #66cdaa; font-size: 13px; font-weight: bold;")
btn_esci.clicked.connect(self.funz_esci)
buttons_layout.addStretch()
buttons_layout.addWidget(btn_esci)
h_layout.addLayout(buttons_layout)
self.setLayout(h_layout)
self.controller.save_data()
#funzione che elimia la prenotazione selezionata
def elimina_prenotazione_click(self):
try:
self.selected = self.list_view.selectedIndexes()[0].row()
prenotazione_selezionata = self.lista_selezionata[self.selected]
controller = ControllorePrenotazione(prenotazione_selezionata)
reply = QMessageBox.question(
self, "Messaggio",
"Sicuro di voler disdire la prenotazione? <p>OPERAZIONE IRREVERSIBILE",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
#se si clissa YES sul messaggio di errore si procede all'eliminazione
if reply == QMessageBox.Yes:
self.controller.elimina_prenotazione_by_id(
controller.get_id_prenotazione())
riga = self.selected
self.tableWidget.removeRow(riga)
# aggiornamento
self.controllorePre.save_data()
# emetto uscita di cassa per disdetta prenotazione
self.movimento = Movimento(
controller.get_data_prenotazione(), "Disdetta campo da " +
str(controller.get_campo_tipo()) + " - ID prenotazione: " +
str(controller.get_id_prenotazione()), "Spesa",
controller.prezzi_campi())
self.controlloreMov.aggiungi_movimento(self.movimento)
self.controlloreMov.save_data()
else:
pass
except:
QMessageBox.critical(
self, 'Errore',
'Per favore, seleziona un movimento da eliminare.',
QMessageBox.Ok, QMessageBox.Ok)
#funzione che modifica la prenotazione selezionata
def modifica_prenotazione_click(self):
try:
self.selected = self.list_view.selectedIndexes()[0].row()
prenotazione_selezionata = self.lista_selezionata[self.selected]
self.modifica_prenotazione = VistaModificaPrenotazione(
prenotazione_selezionata, self.controller, self.update_mod)
self.modifica_prenotazione.show()
except:
QMessageBox.critical(
self, 'Errore',
'Per favore, seleziona una prenotazione da visualizzare.',
QMessageBox.Ok, QMessageBox.Ok)
#funzione che ritorna l'elemento che si trova ad un determinato indice della lista
def get_lista_index(self, index, lista):
return lista[index]
def closeEvent(self, event):
self.controller.save_data()
#crea la tabella
def createTable(self):
self.tableWidget = QTableWidget()
self.tableWidget.setEditTriggers(QTableWidget.NoEditTriggers)
# Row count
rows = 0
self.tableWidget.setRowCount(
len(self.controller.get_lista_prenotazioni()))
# Column count
self.tableWidget.setColumnCount(8)
columns = [
'Cognome', 'Nome', 'Documento', 'Campo', 'Numero', 'Data',
'Ora inizio', 'Ora fine'
]
self.tableWidget.setHorizontalHeaderLabels(columns)
self.controller.ordina(self.controller.get_lista_prenotazioni())
#inserimento prenotazioni nella tableWidget
self.i = 0
self.lista_selezionata = []
for prenotazione in self.controller.get_lista_prenotazioni():
from home.views.VistaHome import VistaHome
if prenotazione.campo.tipo == VistaHome.selezione_campo and prenotazione.data == self.data_selezionata:
self.lista_selezionata.append(prenotazione)
else:
pass
self.controller.ordina(self.lista_selezionata)
for prenotazione in self.lista_selezionata:
self.tableWidget.setItem(self.i, 0,
QTableWidgetItem(prenotazione.cognome))
self.tableWidget.setItem(self.i, 1,
QTableWidgetItem(prenotazione.nome))
self.tableWidget.setItem(self.i, 2,
QTableWidgetItem(prenotazione.documento))
self.tableWidget.setItem(self.i, 3,
QTableWidgetItem(prenotazione.campo.tipo))
self.tableWidget.setItem(
self.i, 4, QTableWidgetItem(prenotazione.campo.numero))
self.tableWidget.setItem(self.i, 5,
QTableWidgetItem(prenotazione.data))
self.tableWidget.setItem(self.i, 6,
QTableWidgetItem(prenotazione.ora_inizio))
self.tableWidget.setItem(self.i, 7,
QTableWidgetItem(prenotazione.ora_fine))
self.i += 1
rows += 1
#risetto le prenotazioni di un giorno specifico
self.tableWidget.setRowCount(rows)
self.tableWidget.horizontalHeader().setStretchLastSection(True)
self.tableWidget.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
def update_mod(self):
self.controller.ordina(self.controller.get_lista_prenotazioni())
# inserimento prenotazioni nella tableWidget
self.i = 0
for prenotazione in self.controller.get_lista_prenotazioni():
self.tableWidget.setItem(self.i, 0,
QTableWidgetItem(prenotazione.cognome))
self.tableWidget.setItem(self.i, 1,
QTableWidgetItem(prenotazione.nome))
self.tableWidget.setItem(self.i, 2,
QTableWidgetItem(prenotazione.documento))
self.i += 1
def funz_esci(self):
self.close()
from calendario.Calendario import Calendario
Calendario.vista_prenotazione = False
self.cal = Calendario()
return self.cal.show()
class VistaModificaPrenotazione(QWidget):
def __init__(self, prenotazione_selezionata, controller, callback):
super(VistaModificaPrenotazione, self).__init__()
self.p = prenotazione_selezionata
self.prenotazione_sel = ControllorePrenotazione(prenotazione_selezionata)
self.controller = controller
self.callback = callback
self.info = {}
self.info = {}
self.c = ControlloreListaPrenotazioni()
self.combo_ora = QComboBox()
self.v_layout = QVBoxLayout()
self.setFixedSize(300, 500)
self.get_form_entry(self.prenotazione_sel.get_nome(),"Nome cliente")
self.get_form_entry(self.prenotazione_sel.get_cognome(),"Cognome cliente")
self.get_form_entry(self.prenotazione_sel.get_documento(),"Documento")
self.get_form_entry(self.prenotazione_sel.get_campo_tipo(),"Tipo campo")
self.numero = QLabel("Numero Campo")
self.v_layout.addWidget(self.numero)
self.radio()
print(QDate.currentDate())
self.data_label = QLabel("Data")
self.v_layout.addWidget(self.data_label)
self.btn_data = QPushButton("Inserisci data")
self.btn_data.clicked.connect(self.visualizza_calendario)
self.v_layout.addWidget(self.btn_data)
self.lista_ore = ["10:00", "10:30", "11:00", "11:30", "12:00", "12:30", "13:00", "13:30", "14:00",
"14:30", "15:00", "15:30", "16:00", "16:30", "17:00", "17:30", "18:00", "18:30",
"19:00", "19:30", "20:00", "20:30", "21:00", "21:30", ]
self.get_combo(self.lista_ore)
self.v_layout.addItem(QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding))
btn_ok = QPushButton("OK")
btn_ok.setStyleSheet("background-color: #90ee90; font-size: 15px; font-weight: bold;")
btn_ok.setShortcut("Return")
btn_ok.clicked.connect(self.add_prenotazione)
self.v_layout.addWidget(btn_ok)
# creazione pulsante di annullamento dell'inserimento
btn_annulla = QPushButton("Annulla")
btn_annulla.setStyleSheet("background-color: #f08080; font-size: 15px; font-weight: bold;")
btn_annulla.setShortcut("Esc")
btn_annulla.clicked.connect(self.close)
self.v_layout.addWidget(btn_annulla)
self.setLayout(self.v_layout)
self.setWindowTitle("Modifica Prenotazione")
#creatore universale di QLineEdit
def get_form_entry(self, campo, tipo):
self.v_layout.addWidget(QLabel(tipo))
current_text_edit = QLineEdit(self)
current_text_edit.setText(campo)
self.v_layout.addWidget(current_text_edit)
self.info[tipo] = current_text_edit
#combo per inserimento orario inizio
def get_combo(self, lista):
self.v_layout.addWidget(QLabel("Ora inizio"))
combo_model = QStandardItemModel(self.combo_ora)
combo_model.appendRow(QStandardItem(""))
for item in lista:
combo_model.appendRow(QStandardItem(item))
self.combo_ora.setModel(combo_model)
self.v_layout.addWidget(self.combo_ora)
#creatore radio button per numero campo
def radio(self):
self.h_layout =QHBoxLayout()
self.radiobuttons1 = QRadioButton("1")
self.radiobuttons1.setChecked(False)
self.h_layout.addWidget(self.radiobuttons1)
self.radiobuttons2 = QRadioButton("2")
self.radiobuttons2.setChecked(False)
self.h_layout.addWidget(self.radiobuttons2)
self.v_layout.addLayout(self.h_layout)
#da qui in poi è uguale a VistaInserisciPrenotazione
def add_prenotazione(self):
nome = self.info["Nome cliente"].text()
cognome = self.info["Cognome cliente"].text()
documento = self.info["Documento"].text()
tipo_campo = self.info["Tipo campo"].text()
ora_inizio = self.combo_ora.currentText()
if self.radiobuttons1.isChecked():
numero_campo = self.radiobuttons1.text()
elif self.radiobuttons2.isChecked():
numero_campo=self.radiobuttons2.text()
else:
numero_campo=""
self.data_unix = self.data_selezionata()
if self.data_unix is None:
self.assegno_data = self.prenotazione_sel.get_data_prenotazione()
print(self.assegno_data + "ASSEGNO DATA")
self.data_form = datetime.strptime(self.assegno_data, '%d/%m/%Y')
self.data_times = datetime.timestamp(self.data_form)
self.data_unix = self.data_times
print(str(self.data_unix) + "DATA UNIX")
else:
self.assegno_data = self.data
today = datetime.today()
today_formattato = today.strftime("%d/%m/%Y")
today_formattato_per_unix= datetime.strptime(today_formattato,'%d/%m/%Y')
today_unix = datetime.timestamp(today_formattato_per_unix)
orario_today = str(today.hour) + ":" + str(today.minute)
if nome == "" or cognome == "" or documento == "" or ora_inizio=="" or numero_campo=="" or self.data_unix is None:
QMessageBox.critical(self, 'Errore', 'Per favore, inserisci tutte le informazioni richieste', QMessageBox.Ok, QMessageBox.Ok)
elif self.data_unix=="Errore":
QMessageBox.critical(self, 'Errore', 'Hai inserito una data passata o una domenica',
QMessageBox.Ok, QMessageBox.Ok)
elif self.data_unix == today_unix:
if ora_inizio < orario_today:
QMessageBox.critical(self, 'Errore', 'Errore hai inserito la data di oggi con un orario già passato',
QMessageBox.Ok, QMessageBox.Ok)
else:
print("Nessun campo d'inserimento vuoto")
self.campo = Campo(tipo_campo, numero_campo)
print("Campo creato")
self.prenotazione = Prenotazione(nome, cognome, documento, self.campo, self.assegno_data, ora_inizio)
print("Prenotazione creata")
if not self.c.get_lista_prenotazioni():
print("La lista è vuota")
self.campo.prenota()
self.controller.aggiungi_prenotazione(self.prenotazione)
self.aggiungi_movimento()
self.callback()
self.controller.save_data()
self.close()
else:
for prenotazione_esistente in self.c.get_lista_prenotazioni():
print("Scorro la lista")
if self.confronta(prenotazione_esistente.data, self.prenotazione.data):
if self.confronta(prenotazione_esistente.campo.tipo, self.prenotazione.campo.tipo):
if self.confronta(prenotazione_esistente.campo.numero, self.prenotazione.campo.numero):
if prenotazione_esistente.ora_inizio <= self.prenotazione.ora_inizio \
and self.prenotazione.ora_inizio < prenotazione_esistente.ora_fine:
print("Errore coincidenza ora inizio")
QMessageBox.critical(self, 'Errore',
"Impossibile effettuare la prenotazione, poichè l'inizio dell'evento è compreso in un altro evento già prenotato",
QMessageBox.Ok, QMessageBox.Ok)
break
elif self.prenotazione.ora_fine > prenotazione_esistente.ora_inizio \
and self.prenotazione.ora_fine < prenotazione_esistente.ora_fine:
print("Errore coincidenza ora fine")
QMessageBox.critical(self, 'Errore',
"Impossibile effettuare la prenotazione, poichè la fine dell'evento è compreso in un altro evento già prenotato",
QMessageBox.Ok, QMessageBox.Ok)
break
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
print("Creato al passo 1")
else:
pass
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
print("Creato al passo 2")
else:
pass
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
print("Creato al passo 3")
else:
pass
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
print("Creato al passo 4")
else:
pass
elif self.data_unix != today_unix:
print("Nessun campo d'inserimento vuoto")
self.campo=Campo(tipo_campo, numero_campo)
print("Campo creato")
self.prenotazione = Prenotazione(nome, cognome, documento, self.campo, self.assegno_data, ora_inizio)
print("Prenotazione creata")
if not self.c.get_lista_prenotazioni():
print("La lista è vuota")
self.campo.prenota()
self.controller.aggiungi_prenotazione(self.prenotazione)
self.aggiungi_movimento()
self.callback()
self.controller.save_data()
self.close()
else:
for prenotazione_esistente in self.c.get_lista_prenotazioni():
print("Scorro la lista")
if self.confronta(prenotazione_esistente.data, self.prenotazione.data):
if self.confronta(prenotazione_esistente.campo.tipo, self.prenotazione.campo.tipo):
if self.confronta(prenotazione_esistente.campo.numero, self.prenotazione.campo.numero):
if prenotazione_esistente.ora_inizio <= self.prenotazione.ora_inizio \
and self.prenotazione.ora_inizio < prenotazione_esistente.ora_fine:
print("Errore coincidenza ora inizio")
QMessageBox.critical(self, 'Errore', "Impossibile effettuare la prenotazione, poichè l'inizio dell'evento è compreso in un altro evento già prenotato",QMessageBox.Ok, QMessageBox.Ok)
break
elif self.prenotazione.ora_fine > prenotazione_esistente.ora_inizio \
and self.prenotazione.ora_fine < prenotazione_esistente.ora_fine:
print("Errore coincidenza ora fine")
QMessageBox.critical(self, 'Errore',"Impossibile effettuare la prenotazione, poichè la fine dell'evento è compreso in un altro evento già prenotato",QMessageBox.Ok, QMessageBox.Ok)
break
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
print("Creato al passo 1")
else:
pass
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
print("Creato al passo 2")
else:
pass
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
print("Creato al passo 3")
else:
pass
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
print("Creato al passo 4")
else:
pass
def aggiungi_data(self):
self.data_da_calendario = QCalendarWidget()
self.data_da_calendario.setGridVisible(True)
self.data_da_calendario.show()
def data_selezionata(self):
#vedere se bisogna fare queste successive 4 righe anche in VistaAbbonamento e VistaCertificato, perche il .today
#ritorna anche i secondi nel timestamp
oggi = datetime.today()
oggi_formattato = oggi.strftime("%d/%m/%Y")
oggi_formattato_per_unix = datetime.strptime(oggi_formattato, '%d/%m/%Y')
oggi_unix = datetime.timestamp(oggi_formattato_per_unix)
print("Oggi: " + str(oggi_unix))
try:
data_selezionata = self.calendario.selectedDate()
self.data = "{}/{}/{}".format(data_selezionata.day(), data_selezionata.month(), data_selezionata.year())
data_selezionata_formattata = datetime.strptime(self.data, '%d/%m/%Y')
data_timestamp = datetime.timestamp(data_selezionata_formattata)
print("Data selezionata: " + str(data_timestamp))
if oggi_unix <= data_timestamp and data_selezionata.dayOfWeek() != 7:
self.calendario.close()
return data_timestamp
elif data_timestamp is None:
return None
elif data_timestamp < oggi_unix:
return("Errore")
except:
pass
def visualizza_calendario(self):
self.window = QWidget()
self.v1_layout = QVBoxLayout()
self.calendario = QCalendarWidget()
self.calendario.setGridVisible(True)
self.v1_layout.addWidget(self.calendario)
self.btn_conferma = QPushButton("Conferma")
self.btn_conferma.clicked.connect(self.window.close)
self.v1_layout.addWidget(self.btn_conferma)
self.window.setLayout(self.v1_layout)
self.window.show()
def crea_parametri(self):
self.campo.prenota()
self.controller.rimuovi_dalla_lista(self.p)
self.controller.save_data()
self.controller.aggiungi_prenotazione(self.prenotazione)
self.controller.save_data()
self.callback()
from calendario.Calendario import Calendario
self.close()
self.controller.save_data()
self.mostra_calendario = Calendario()
return self.mostra_calendario.show()
def confronta(self,prenotazione_esistente, nuova_prenotazione):
if prenotazione_esistente == nuova_prenotazione:
return True
else:
return None
def verifica_ultimo_elemento_lista(self, prenotazione_corrente):
if prenotazione_corrente == self.c.get_prenotazione_by_index(len(self.c.get_lista_prenotazioni()) - 1):
return True
else:
return None
def __init__(self, controller, callback):
super(VistaInserisciPrenotazione, self).__init__()
self.setFixedSize(300,600)
self.controller = controller
self.callback = callback
#dizionario vuoto
self.info = {}
self.c = ControlloreListaPrenotazioni()
self.controlloreMov = ControlloreListaMovimenti()
#layout per l'inserimento dei campi della prenotazione
self.combo_ora = QComboBox()
self.v_layout = QVBoxLayout()
self.v_layout.addStretch()
lbl_titolo = QLabel("<b>Nuova prenotazione</b>")
font = lbl_titolo.font()
font.setPointSize(20)
lbl_titolo.setFont(font)
lbl_titolo.setAlignment(Qt.AlignCenter)
self.v_layout.addWidget(lbl_titolo)
self.v_layout.addStretch()
self.get_form_entry("Nome cliente")
self.get_form_entry("Cognome cliente")
self.get_form_entry("Documento")
self.get_form_entry("Tipo campo")
self.numero = QLabel("Numero Campo")
self.v_layout.addWidget(self.numero)
self.radio()
self.data_label = QLabel("Data")
self.v_layout.addWidget(self.data_label)
self.line_data = QLineEdit()
self.line_data.setReadOnly(True)
self.v_layout.addWidget(self.line_data)
#bottone data che al click ci apre il calendario per scegliere una data
self.btn_data = QPushButton("Inserisci data")
self.btn_data.clicked.connect(self.visualizza_calendario)
self.v_layout.addWidget(self.btn_data)
self.lista_ore = ["10:00", "10:30", "11:00", "11:30", "12:00", "12:30", "13:00", "13:30", "14:00",
"14:30", "15:00","15:30", "16:00", "16:30", "17:00", "17:30", "18:00", "18:30",
"19:00", "19:30", "20:00", "20:30", "21:00", "21:30",]
self.get_combo(self.lista_ore)
self.v_layout.addItem(QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding))
btn_ok = QPushButton("OK")
btn_ok.setStyleSheet("background-color: #90ee90; font-size: 13px; font-weight: bold;")
btn_ok.setShortcut("Return")
btn_ok.clicked.connect(self.add_prenotazione)
self.v_layout.addWidget(btn_ok)
# creazione pulsante di annullamento dell'inserimento
btn_annulla = QPushButton("Annulla")
btn_annulla.setStyleSheet("background-color: #f08080; font-size: 13px; font-weight: bold;")
btn_annulla.setShortcut("Esc")
btn_annulla.clicked.connect(self.funz_esci)
self.v_layout.addWidget(btn_annulla)
self.v_layout.addStretch()
self.setLayout(self.v_layout)
self.setWindowTitle("Nuova Prenotazione")
class VistaInserisciPrenotazione(QWidget):
def __init__(self, controller, callback):
super(VistaInserisciPrenotazione, self).__init__()
self.setFixedSize(300,600)
self.controller = controller
self.callback = callback
#dizionario vuoto
self.info = {}
self.c = ControlloreListaPrenotazioni()
self.controlloreMov = ControlloreListaMovimenti()
#layout per l'inserimento dei campi della prenotazione
self.combo_ora = QComboBox()
self.v_layout = QVBoxLayout()
self.v_layout.addStretch()
lbl_titolo = QLabel("<b>Nuova prenotazione</b>")
font = lbl_titolo.font()
font.setPointSize(20)
lbl_titolo.setFont(font)
lbl_titolo.setAlignment(Qt.AlignCenter)
self.v_layout.addWidget(lbl_titolo)
self.v_layout.addStretch()
self.get_form_entry("Nome cliente")
self.get_form_entry("Cognome cliente")
self.get_form_entry("Documento")
self.get_form_entry("Tipo campo")
self.numero = QLabel("Numero Campo")
self.v_layout.addWidget(self.numero)
self.radio()
self.data_label = QLabel("Data")
self.v_layout.addWidget(self.data_label)
self.line_data = QLineEdit()
self.line_data.setReadOnly(True)
self.v_layout.addWidget(self.line_data)
#bottone data che al click ci apre il calendario per scegliere una data
self.btn_data = QPushButton("Inserisci data")
self.btn_data.clicked.connect(self.visualizza_calendario)
self.v_layout.addWidget(self.btn_data)
self.lista_ore = ["10:00", "10:30", "11:00", "11:30", "12:00", "12:30", "13:00", "13:30", "14:00",
"14:30", "15:00","15:30", "16:00", "16:30", "17:00", "17:30", "18:00", "18:30",
"19:00", "19:30", "20:00", "20:30", "21:00", "21:30",]
self.get_combo(self.lista_ore)
self.v_layout.addItem(QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding))
btn_ok = QPushButton("OK")
btn_ok.setStyleSheet("background-color: #90ee90; font-size: 13px; font-weight: bold;")
btn_ok.setShortcut("Return")
btn_ok.clicked.connect(self.add_prenotazione)
self.v_layout.addWidget(btn_ok)
# creazione pulsante di annullamento dell'inserimento
btn_annulla = QPushButton("Annulla")
btn_annulla.setStyleSheet("background-color: #f08080; font-size: 13px; font-weight: bold;")
btn_annulla.setShortcut("Esc")
btn_annulla.clicked.connect(self.funz_esci)
self.v_layout.addWidget(btn_annulla)
self.v_layout.addStretch()
self.setLayout(self.v_layout)
self.setWindowTitle("Nuova Prenotazione")
# fine layout per l'inserimento dei campi della prenotazione
#funzione per tenere il tipo di campo selezionato inizialmente nel campo relativo al tipo campo
def get_form_entry(self, tipo):
self.v_layout.addWidget(QLabel("<b>{}</b>".format(tipo)))
current_text_edit = QLineEdit(self)
font = current_text_edit.font()
font.setPointSize(15)
current_text_edit.setFont(font)
self.v_layout.addWidget(current_text_edit)
if tipo =="Tipo campo":
from home.views.VistaHome import VistaHome
current_text_edit.setText(VistaHome.selezione_campo)
current_text_edit.setReadOnly(True)
self.info[tipo] = current_text_edit
#permette la scelta di una delle ore nella lista passata in argomento
def get_combo(self, lista):
self.v_layout.addWidget(QLabel("Ora inizio"))
combo_model = QStandardItemModel(self.combo_ora)
combo_model.appendRow(QStandardItem(""))
for item in lista:
combo_model.appendRow(QStandardItem(item))
self.combo_ora.setModel(combo_model)
self.v_layout.addWidget(self.combo_ora)
#funzione per la creazione dei radio button relativi al numero del campo
def radio(self):
self.h_layout =QHBoxLayout()
self.radiobuttons1 = QRadioButton("1")
self.radiobuttons1.setChecked(False)
self.h_layout.addWidget(self.radiobuttons1)
self.radiobuttons2 = QRadioButton("2")
self.radiobuttons2.setChecked(False)
self.h_layout.addWidget(self.radiobuttons2)
self.v_layout.addLayout(self.h_layout)
#funzione che permette di aggiungere una prenotazione
def add_prenotazione(self):
from calendario.Calendario import Calendario
Calendario.vista_prenotazione = False
#assegnamento dei campi con testo
nome = self.info["Nome cliente"].text()
cognome = self.info["Cognome cliente"].text()
documento = self.info["Documento"].text()
tipo_campo = self.info["Tipo campo"].text()
#assegnamento ora inizio in base a quella scelta
ora_inizio = self.combo_ora.currentText()
#assegnamento numero campo in base al radiobutton selezionato
if self.radiobuttons1.isChecked():
numero_campo = self.radiobuttons1.text()
elif self.radiobuttons2.isChecked():
numero_campo=self.radiobuttons2.text()
else:
numero_campo=""
#assegnamento della data
data_unix = self.data_selezionata()
#formattazione della data di oggi per vari confronti
today = datetime.today()
today_formattato = today.strftime("%d/%m/%Y")
today_formattato_per_unix= datetime.strptime(today_formattato,'%d/%m/%Y')
today_unix = datetime.timestamp(today_formattato_per_unix)
orario_today = str(today.hour) + ":" + str(today.minute)
#controlliamo che tutti i campi siano inseriti
if nome == "" or cognome == "" or documento == "" or ora_inizio=="" or numero_campo=="" or data_unix is None:
QMessageBox.critical(self, 'Errore', 'Per favore, inserisci tutte le informazioni richieste', QMessageBox.Ok, QMessageBox.Ok)
#controlliamo la data inserita
elif data_unix=="Errore":
QMessageBox.critical(self, 'Errore', 'Hai inserito una data passata o una domenica',
QMessageBox.Ok, QMessageBox.Ok)
#controlliamo che se la data è quella odierna l'orario sia un orario accettabile
elif data_unix == today_unix:
if ora_inizio < orario_today:
QMessageBox.critical(self, 'Errore', 'Errore hai inserito la data di oggi con un orario già passato',
QMessageBox.Ok, QMessageBox.Ok)
else:
self.campo = Campo(tipo_campo, numero_campo)
self.prenotazione = Prenotazione(nome, cognome, documento, self.campo, self.data, ora_inizio)
#se la lista è vuota prenotiamo il campo e aggiorniamo i movimenti della cassa
if not self.c.get_lista_prenotazioni():
self.crea_parametri()
#se la lista non è vuota
else:
for prenotazione_esistente in self.c.get_lista_prenotazioni():
#controlliamo che la prenotazione che si vuole fare sia valida, non vada in conflitto con altre
if self.confronta(prenotazione_esistente.data, self.prenotazione.data):
if self.confronta(prenotazione_esistente.campo.tipo, self.prenotazione.campo.tipo):
if self.confronta(prenotazione_esistente.campo.numero, self.prenotazione.campo.numero):
if prenotazione_esistente.ora_inizio <= self.prenotazione.ora_inizio \
and self.prenotazione.ora_inizio < prenotazione_esistente.ora_fine:
#l'ora di inizio è compresa in un'altra fascia oraria
QMessageBox.critical(self, 'Errore',
"Impossibile effettuare la prenotazione, poichè l'inizio dell'evento è compreso in un altro evento già prenotato",
QMessageBox.Ok, QMessageBox.Ok)
break
elif self.prenotazione.ora_fine > prenotazione_esistente.ora_inizio \
and self.prenotazione.ora_fine < prenotazione_esistente.ora_fine:
#l'ora di fine è compresa in un'altra fascia oraria
QMessageBox.critical(self, 'Errore',
"Impossibile effettuare la prenotazione, poichè la fine dell'evento è compreso in un altro evento già prenotato",
QMessageBox.Ok, QMessageBox.Ok)
break
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
else:
pass
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
else:
pass
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
else:
pass
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
else:
pass
#se la data selezionata è diversa da quella odierna
elif data_unix != today_unix:
self.campo=Campo(tipo_campo, numero_campo)
self.prenotazione = Prenotazione(nome, cognome, documento, self.campo, self.data, ora_inizio)
#se la lista è vuota
if not self.c.get_lista_prenotazioni():
self.campo.prenota()
self.controller.aggiungi_prenotazione(self.prenotazione)
self.aggiungi_movimento()
self.callback()
self.controller.save_data()
self.close()
else:
for prenotazione_esistente in self.c.get_lista_prenotazioni():
if self.confronta(prenotazione_esistente.data, self.prenotazione.data):
if self.confronta(prenotazione_esistente.campo.tipo, self.prenotazione.campo.tipo):
if self.confronta(prenotazione_esistente.campo.numero, self.prenotazione.campo.numero):
if prenotazione_esistente.ora_inizio <= self.prenotazione.ora_inizio \
and self.prenotazione.ora_inizio < prenotazione_esistente.ora_fine:
QMessageBox.critical(self, 'Errore', "Impossibile effettuare la prenotazione, poichè l'inizio dell'evento è compreso in un altro evento già prenotato",QMessageBox.Ok, QMessageBox.Ok)
break
elif self.prenotazione.ora_fine > prenotazione_esistente.ora_inizio \
and self.prenotazione.ora_fine < prenotazione_esistente.ora_fine:
QMessageBox.critical(self, 'Errore',"Impossibile effettuare la prenotazione, poichè la fine dell'evento è compreso in un altro evento già prenotato",QMessageBox.Ok, QMessageBox.Ok)
break
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
else:
pass
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
else:
pass
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
else:
pass
else:
if self.verifica_ultimo_elemento_lista(prenotazione_esistente):
print(prenotazione_esistente.nome + prenotazione_esistente.cognome)
self.crea_parametri()
else:
pass
#ritorna la data nel formato timestamp
def data_selezionata(self):
#ritorna anche i secondi nel timestamp
oggi = datetime.today()
oggi_formattato = oggi.strftime("%d/%m/%Y")
oggi_formattato_per_unix = datetime.strptime(oggi_formattato, '%d/%m/%Y')
oggi_unix = datetime.timestamp(oggi_formattato_per_unix)
try:
#assegnamento della data selezionata sul calendario
data_selezionata = self.calendario.selectedDate()
#formattazione della data in un formato leggibile dall'utente
self.data = "{}/{}/{}".format(data_selezionata.day(), data_selezionata.month(), data_selezionata.year())
data_selezionata_formattata = datetime.strptime(self.data, '%d/%m/%Y')
data_timestamp = datetime.timestamp(data_selezionata_formattata)
#se la data è selezionata è maggiore o uguale all'odierna e non è una domenica ritorniamo il timestamp
if oggi_unix <= data_timestamp and data_selezionata.dayOfWeek() != 7:
self.calendario.close()
return data_timestamp
#se non è stata selezionata una data
elif data_timestamp is None:
return None
#se la data selezionata è già passata
elif data_timestamp < oggi_unix:
return("Errore")
except:
pass
#funzione per mostrare il calendario
def visualizza_calendario(self):
self.window = QWidget()
self.v1_layout = QVBoxLayout()
self.calendario = QCalendarWidget()
self.calendario.setGridVisible(True)
self.v1_layout.addWidget(self.calendario)
self.btn_conferma = QPushButton("Conferma")
self.btn_conferma.clicked.connect(self.chiudi_calendario)
self.v1_layout.addWidget(self.btn_conferma)
self.window.setLayout(self.v1_layout)
self.window.show()
#chiude il calendario e salva la data selezionata
def chiudi_calendario(self):
self.window.close()
data_selezionata = self.calendario.selectedDate()
self.data = "{}/{}/{}".format(data_selezionata.day(), data_selezionata.month(), data_selezionata.year())
self.line_data.setText("{}".format(self.data))
#applica la prenotazione di un campo e aggiunge i movimenti in cassa
def crea_parametri(self):
self.campo.prenota()
self.controller.aggiungi_prenotazione(self.prenotazione)
self.aggiungi_movimento()
self.callback()
self.controller.save_data()
self.close()
#funzione che confronta se la nuova prenotazione è uguale ad una esistente. In particolare la usiamo per confrontare
#uno ad uno i campi delle due prenotazioni
def confronta(self,prenotazione_esistente, nuova_prenotazione):
if prenotazione_esistente == nuova_prenotazione:
return True
else:
return None
#verifichiamo se siamo arrivati all'ultimo elemento della lista
def verifica_ultimo_elemento_lista(self, prenotazione_corrente):
if prenotazione_corrente == self.c.get_prenotazione_by_index(len(self.c.get_lista_prenotazioni()) - 1):
return True
else:
return None
#creiamo e aggiungiamo il movimento nella lista dei movimenti
def aggiungi_movimento(self):
self.movimento = Movimento(self.data, "Prenotazione campo da " + self.info["Tipo campo"].text() + " - ID prenotazione: " + str(self.prenotazione.id),"Incasso", float(self.prenotazione.prezzi_campi()))
self.movimento.isEntrata = True
print("Stiamo aggiungendo")
self.controlloreMov.aggiungi_movimento(self.movimento)
print("Abbiamo aggiunto")
self.controlloreMov.save_data()
print("Abbiamo salvato")
def funz_esci(self):
self.close()
from calendario.Calendario import Calendario
Calendario.vista_prenotazione = False
