def info_booking(bot, update):
"""
Fornisce delle semplici informazioni all'utente riguardo il funzionamento delle prenotazioni.
"""
chat_id = str(update.callback_query.from_user.id)
if common.is_sessione():
text = "Durante le sessioni d'esame, tutte le prenotazioni valgono per una e una sola volta." \
" Non sono previste distinzioni tra prenotazioni temporanee o permanenti."
else:
text = "Prenotazione *Temporanea (una-tantum)*:" \
"\nLe prenotazioni una-tantum valgono per una singola volta . Una volta completato il" \
" viaggio, vengono automaticamente cancellate ed addebitate il giorno dopo la prenotazione." \
" E' possibile prenotarsi a un viaggio già avvenuto nella stessa giornata, ma verrà addebitato" \
" comunque e non sarà valido per la settimana successiva." \
"\n\nPrenotazione *Permanente*" \
"\nLe prenotazioni permanenti valgono dal momento della prenotazione fino alla" \
" cancellazione del viaggio o della prenotazione, ogni settimana. Verranno" \
" addebitate anche per i viaggi prenotati per la giornata corrente."
keyboard = [[
InlineKeyboardButton("↩ Indietro", callback_data=ccd("BOOKING_MENU"))
], [InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]]
bot.edit_message_text(chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=text,
parse_mode="Markdown",
reply_markup=InlineKeyboardMarkup(keyboard))
def parcheggio(bot, update):
chat_id = str(update.message.chat_id)
# Controllo per evitare che i non autisti usino il comando
if not is_driver(chat_id):
return
keyboard = [
[InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]
]
day = common.today()
day_trips = get_trip_group("Discesa", day)
if common.is_weekday(day):
if chat_id in day_trips and not day_trips[chat_id]["Suspended"]:
for location in common.locations:
keyboard.insert(0, [InlineKeyboardButton(location, callback_data=ccd("CONFIRM_PARK", location))])
if "Location" in day_trips[chat_id]:
message = f"La posizione di ritrovo corrente è settata a: {day_trips[chat_id]['Location']}." \
f"\nSeleziona un nuovo luogo di ritrovo."
else:
message = "Seleziona il luogo di ritrovo per il viaggio di ritorno."
else:
message = "Mi dispiace, non sembra che tu abbia viaggi in programma da Povo verso il NEST oggi." \
" Inseriscine uno e riprova.",
else:
message = "Mi dispiace, è possibile selezionare il luogo di parcheggio nei giorni in cui UberNEST è attivo.",
bot.send_message(chat_id=chat_id, text=message, reply_markup=InlineKeyboardMarkup(keyboard))
def booking_keyboard(mode, day, show_bookings=True):
keyboard = []
if common.is_sessione():
today_number = datetime.datetime.today().weekday()
for item in range(len(common.days)):
_day = common.day_to_string((item + today_number) % len(common.days))
if _day == "Sabato" or _day == "Domenica": # Sabato, domenica
continue
bookings = get_all_trips_day(_day)
for time, name, direction, driver in bookings:
if not is_suspended(direction, _day, driver):
shortened_direction = "Povo" if direction == "Salita" else "NEST"
keyboard.append(
[InlineKeyboardButton(f"🚗 {name.split(' ')[-1]}/"
f"{_day[:2]} "
f"{datetime.datetime.today().day + item} "
f"{time}/{shortened_direction}",
callback_data=ccd("BOOKING", "CONFIRM", direction,
_day, driver, "Temporary"))])
keyboard.append([InlineKeyboardButton(f"Vai a /oggi", callback_data=ccd("SHOW_BOOKINGS", "Lunedì"))])
keyboard.append([InlineKeyboardButton("↩ Indietro", callback_data=ccd("BOOKING_MENU"))])
else:
if show_bookings:
bookings = get_all_trips_day(day)
for time, name, direction, driver in bookings:
if not is_suspended(direction, day, driver):
keyboard.append(
[InlineKeyboardButton(f"🚗 {name.split(' ')[-1]} 🕓 {time} "
f"{common.dir_name(direction)}",
callback_data=ccd("BOOKING", "CONFIRM", direction, day, driver, mode))])
day_subkeyboard = []
for wkday in common.work_days:
text = "☑" if wkday == day and show_bookings else wkday[:2]
day_subkeyboard.append(InlineKeyboardButton(text, callback_data=ccd("BOOKING", "DAY", mode, wkday)))
alternate_text = "🔂 Cambia metodo (Temp.)" if mode == "Permanent" else "🔁 Cambia metodo (Perm.)"
alternate_payload = "Temporary" if mode == "Permanent" else "Permanent"
alternate_ccd = ccd("BOOKING", "DAY", alternate_payload, day) if show_bookings else \
ccd("BOOKING", "START", alternate_payload)
keyboard.append(day_subkeyboard)
keyboard.append([InlineKeyboardButton(alternate_text, callback_data=alternate_ccd)])
if show_bookings:
keyboard.append(
[InlineKeyboardButton(f"Vai a /{day[:-1].lower()}ì", callback_data=ccd("SHOW_BOOKINGS", day))])
else:
keyboard.append([InlineKeyboardButton("↩ Indietro", callback_data=ccd("BOOKING_MENU"))])
keyboard.append([InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))])
return InlineKeyboardMarkup(keyboard)
def confirm_parking(bot, update):
chat_id = str(update.callback_query.message.chat_id)
data = separate_callback_data(update.callback_query.data)
location = data[1]
keyboard = [
[InlineKeyboardButton("📍 Mostra sulla mappa", callback_data=ccd("SEND_LOCATION", location))],
[InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]
]
day_group = get_trip("Discesa", common.today(), chat_id)
day_group["Location"] = location
bot.edit_message_text(chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=f"Posizione impostata con successo: {location}",
reply_markup=InlineKeyboardMarkup(keyboard))
for passenger_group in day_group["Temporary"], day_group["Permanent"]:
for passenger in passenger_group:
bot.send_message(chat_id=passenger,
text=f"Per il viaggio di ritorno,"
f" [{get_name(chat_id)}](tg://user?id={chat_id})"
f" ha impostato il luogo di ritrovo:\n📍 {location}.",
reply_markup=InlineKeyboardMarkup(keyboard))
def trips_keyboard(chat_id):
keyboard = [[InlineKeyboardButton("Aggiungi un nuovo viaggio", callback_data=ccd("TRIPS", "ADD"))]]
today_number = datetime.datetime.today().weekday()
for item in range(len(common.days)):
day = common.day_to_string((item + today_number) % len(common.days))
if day == "Sabato" or day == "Domenica": # Sabato, domenica
continue
for direction in "Salita", "Discesa":
try:
group = get_trip(direction, day, chat_id)
if group["Suspended"]:
counter = "SOSP."
else:
counter = f"{len(group['Permanent']) + len(group['Temporary'])}"
if common.is_sessione():
shown_day = f"{day} {datetime.datetime.today().day + item}"
else:
shown_day = day
keyboard.append(
[InlineKeyboardButton(f"{shown_day}: {group['Time']}"
f" {common.dir_name(direction)} ({counter})",
callback_data=ccd("TRIPS", "EDIT_TRIP", direction, day))])
except Exception: # Viaggio non segnato...
continue
keyboard.append([InlineKeyboardButton("↩ Indietro", callback_data=ccd("ME_MENU"))])
keyboard.append([InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))])
return InlineKeyboardMarkup(keyboard)
def check_money(bot, update):
chat_id = str(update.callback_query.message.chat_id)
keyboard = [[
InlineKeyboardButton("↩ Indietro", callback_data=ccd("ME_MENU"))
], [InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]]
message = []
# Prima raccolgo sottoforma di stringa i debiti (per tutti gli utenti)
debit_list = get_debit_tuple(chat_id)
if len(debit_list) > 0:
people = []
for creditor_id, value in debit_list:
people.append(
f"[{get_name(creditor_id)}](tg://user?id={creditor_id})"
f" 🚗 {str(value)} {'viaggi' if value > 1 else 'viaggio'}\n")
message.append(
f"💸 Al momento risultano viaggi da pagare alle seguenti persone:\n{''.join(people)}"
f"\nContatta ciascun autista per saldare i relativi debiti.")
else:
message.append("💰 Al momento non hai viaggi non saldati.")
# Poi creo un bottone separato per ogni credito.
# Questa sezione del codice viene fatta girare solo se l'utente è un autista.
if is_driver(chat_id):
keyboard.insert(0, [
InlineKeyboardButton("âž• Aggiungi un nuovo debitore",
callback_data=ccd("NEW_DEBITOR", 0))
])
credit_list = get_credits(chat_id)
if len(credit_list) > 0:
for debitor_id, value in credit_list:
keyboard.insert(0, [
InlineKeyboardButton(
f"{get_name(debitor_id)} 🚗 {str(value)} {'viaggi' if value > 1 else 'viaggio'}",
callback_data=ccd("EDIT_MONEY", "VIEW", debitor_id))
])
message.append(
"\n\n💰 Al momento possiedi queste persone hanno viaggi non saldati con te. "
"Clicca su una persona per modificare o azzerare il debito:")
else:
message.append("\n\n💸 Nessuno ti deve denaro al momento.")
bot.edit_message_text(chat_id=chat_id,
message_id=update.callback_query.message.message_id,
parse_mode="Markdown",
text="".join(message),
reply_markup=InlineKeyboardMarkup(keyboard))
def new_debitor(bot, update):
"""
Questo metodo lista tutti gli utenti del sistema, selezionabili per aggiungere un nuovo debito.
I potenziali passeggeri vengono listati su più pagine per evitare messaggi infiniti. A ogni pagina è
associata un bottone che permette di aprirla immediatamente. In ogni pagina vi sono PAGE_SIZE persone,
costante definita in util/common.py.
Una volta selezionato un utente, viene aperto edit_money(bot, update) con il debito automaticamente
settato a zero.
"""
chat_id = str(update.callback_query.message.chat_id)
page = int(separate_callback_data(update.callback_query.data)[1])
keyboard = []
users = get_new_debitors(chat_id)
for index in range(PAGE_SIZE * page, PAGE_SIZE * (page + 1), 1):
try:
name, name_chat_id = users[index]
keyboard.append([
InlineKeyboardButton(name,
callback_data=ccd("EDIT_MONEY", "NEW",
name_chat_id))
])
except IndexError:
break
# Aggiungo un bottone per ogni pagina, in quanto la lista è troppo grande
page_buttons = []
for index in range(0, int(math.ceil(len(users) / PAGE_SIZE)), 1):
if index == page:
text = "☑"
else:
text = str(index + 1)
page_buttons.append(
InlineKeyboardButton(text, callback_data=ccd("NEW_DEBITOR",
index)))
keyboard.append(page_buttons)
keyboard.append(
[InlineKeyboardButton("↩ Indietro", callback_data=ccd("MONEY"))])
keyboard.append(
[InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))])
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text="Scegli un utente a cui aggiungere un viaggio da pagare.",
reply_markup=InlineKeyboardMarkup(keyboard))
def fetch_sessione():
text = ["Riepilogo viaggi:"]
today_number = datetime.datetime.today().weekday()
for item in range(len(common.days)):
day = common.day_to_string((item + today_number) % len(common.days))
if day == "Sabato" or day == "Domenica": # Sabato, domenica
continue
empty_day = True
for direction in "Salita", "Discesa":
bookings = get_all_trips_fixed_direction(direction, day)
if len(bookings) > 0:
if empty_day:
text.append(
f"\n\n🗓 Viaggi di {day.lower()} {datetime.datetime.today().day + item}"
)
empty_day = False
for time, driver in bookings:
trip = get_trip(direction, day, driver)
# Raccolgo in una list comprehension le persone che partecipano al viaggio
people = [
f"[{get_name(user)}](tg://user?id={user})"
for user in trip["Temporary"]
]
# Aggiungo ogni viaggio trovato alla lista
text.append(
f"\n🚗 [{get_name(driver)}](tg://user?id={driver}) "
f"(*{time}*, {common.dir_name(direction)}): {', '.join(people)}\n"
)
if empty_day:
text.append(
f"\n😱 Nessuno viaggio previsto per {day.lower()} {datetime.datetime.today().day + item}."
)
keyboard = [[
InlineKeyboardButton("🔂 Prenota",
callback_data=ccd("BOOKING", "START",
"Temporary"))
], [InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]]
return "".join(text), InlineKeyboardMarkup(keyboard)
def me_keyboard(chat_id):
keyboard = []
if is_driver(chat_id):
trips_string = "💰 Gestire i debiti e crediti"
driver_string = "🚫 Smettere di essere un autista"
keyboard.append([InlineKeyboardButton("🚗 Gestire i miei viaggi", callback_data=ccd("ME", "TRIPS"))])
keyboard.append([InlineKeyboardButton(f"{common.emoji_numbers[get_slots(chat_id)]}"
f" Modificare il numero di posti", callback_data=ccd("ME", "ED_DR_SL"))])
else:
trips_string = "💸 Gestire i debiti"
driver_string = "🚗 Diventare un autista"
keyboard.append([InlineKeyboardButton(trips_string, callback_data=ccd("MONEY"))])
keyboard.append([InlineKeyboardButton(driver_string, callback_data=ccd("ME", "DRIVER"))])
keyboard.append([InlineKeyboardButton("❌ Cancellarmi da UberNEST", callback_data=ccd("ME", "US_RE"))])
keyboard.append([InlineKeyboardButton("🔚 Uscire", callback_data=ccd("EXIT"))])
return InlineKeyboardMarkup(keyboard)
def booking_menu_keyboard():
if common.is_sessione():
return InlineKeyboardMarkup([
[InlineKeyboardButton("🔂 Prenotare",
callback_data=ccd("BOOKING", "START", "Temporary"))],
[InlineKeyboardButton("📚 Gestire le mie prenotazioni",
callback_data=ccd("EDIT_BOOK", "LIST"))],
[InlineKeyboardButton("ℹ Informarmi sulle modalità",
callback_data=ccd("INFO_BOOK"))],
[InlineKeyboardButton("🔚 Uscire", callback_data=ccd("EXIT"))]
])
else:
return InlineKeyboardMarkup([
[InlineKeyboardButton("🔂 Prenotare una-tantum",
callback_data=ccd("BOOKING", "START", "Temporary"))],
[InlineKeyboardButton("🔁 Prenotare in maniera permanente",
callback_data=ccd("BOOKING", "START", "Permanent"))],
[InlineKeyboardButton("📚 Gestire le mie prenotazioni",
callback_data=ccd("EDIT_BOOK", "LIST"))],
[InlineKeyboardButton("ℹ Informarmi sulle modalità",
callback_data=ccd("INFO_BOOK"))],
[InlineKeyboardButton("🔚 Uscire", callback_data=ccd("EXIT"))]
])
def fetch_bookings(chat_id, day):
if common.is_weekday(day):
text = [f"Lista dei viaggi di {day.lower()}:"]
for direction in "Salita", "Discesa":
text.append(f"\n\n{common.dir_name(direction)}\n")
bookings = get_all_trips_fixed_direction(direction, day)
if len(bookings) > 0:
for time, driver in bookings:
trip = get_trip(direction, day, driver)
# Raccolgo in una list comprehension le persone che partecipano al viaggio
people = [
f"[{get_name(user)}](tg://user?id={user})"
for mode in trip
if mode == "Temporary" or mode == "Permanent"
for user in trip[mode]
]
# Aggiungo ogni viaggio trovato alla lista
text.append(
f"\n🚗 [{get_name(driver)}](tg://user?id={driver})"
f" - 🕓 *{time}*:"
f"\n👥 {', '.join(people)}\n")
else:
text.append("\n🚶🏻♂ Nessuna persona in viaggio oggi.")
if is_registered(chat_id):
day_subkeyboard = []
for wkday in common.work_days:
ccd_text = "☑" if wkday == day else wkday[:2]
day_subkeyboard.append(
InlineKeyboardButton(ccd_text,
callback_data=ccd(
"SHOW_BOOKINGS", wkday)))
if common.is_booking_time():
keyboard = [
day_subkeyboard,
[
InlineKeyboardButton("🔂 Prenota una tantum",
callback_data=ccd(
"BOOKING", "DAY", "Temporary",
day))
],
[
InlineKeyboardButton("🔁 Prenota permanentemente",
callback_data=ccd(
"BOOKING", "DAY", "Permanent",
day))
],
[
InlineKeyboardButton("🔚 Esci",
callback_data=ccd("EXIT"))
]
]
else:
keyboard = [
day_subkeyboard,
[
InlineKeyboardButton("🔚 Esci",
callback_data=ccd("EXIT"))
]
]
else:
keyboard = []
return "".join(text), InlineKeyboardMarkup(keyboard)
else:
keyboard = [[
InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))
]]
return f"{day} UberNEST non è attivo.", InlineKeyboardMarkup(keyboard)
def booking_handler(bot, update):
"""
Gestore dei metodi delle prenotazioni. Da questo menù è possibile aggiungere prenotazioni.
"""
data = separate_callback_data(update.callback_query.data)
action = data[1]
chat_id = str(update.callback_query.message.chat_id)
#
# Dati in entrata ("BOOKING", "START", mode)
# Questo menù viene chiamato solo dal menù /prenota e mostra solo i giorni disponibili.
#
if action == "START":
mode = data[2]
if common.is_booking_time():
if common.is_sessione():
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=f"Scegli la prenotazione.",
reply_markup=booking_keyboard(mode, common.today()))
else:
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=f"{common.mode_name(mode)}"
f"\n\nSeleziona il giorno della prenotazione.",
reply_markup=booking_keyboard(mode,
common.today(),
show_bookings=False))
else:
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=f"Mi dispiace, non è possibile effettuare prenotazioni"
f" tramite UberNEST dalle 02:00 alle 02:15.")
#
# Dati in entrata ("BOOKING", "DAY", mode, day)
# Questo menù viene chiamato rispettivamente dal metodo sopra (BOOKING) e dai visualizzatori
# delle prenotazioni dei singoli giorni (/lunedi, /martedi, etc...).
#
elif action == "DAY":
mode, day = data[2:4]
if day not in common.work_days:
# Caso in cui siamo di sabato o domenica
day = common.work_days[0]
if common.is_booking_time():
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=f"🗓 {day}"
f"\n{common.mode_name(mode)}"
f"\n\nSeleziona il viaggio da prenotare.",
reply_markup=booking_keyboard(mode, day))
else:
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=f"Mi dispiace, non è possibile effettuare prenotazioni"
f" tramite UberNEST dalle 02:30 alle 03:30.")
#
# Dati in entrata ("BOOKING", "CONFIRM", direction, day, driver, mode)
# Messaggio finale di conferma all'utente e all'autista. Il metodo calcola se la prenotazione scelta è
# legale (ovvero che è disponibile spazio nell'auto, che il passeggero non è l'autista e che non si è
# già prenotato). In caso positivo viene avvisato anche l'autista dell'avvenuta prenotazione
#
elif action == "CONFIRM":
direction, day, driver, mode = data[2:]
user_keyboard = [[
InlineKeyboardButton("↩ Indietro",
callback_data=ccd("BOOKING", "START", mode))
], [InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]]
trip = get_trip(direction, day, driver)
occupied_slots = len(trip["Permanent"]) + len(trip["Temporary"])
total_slots = get_slots(driver)
# Caso in cui l'autista tenta inutilmente di prenotarsi con sè stesso...
if chat_id == driver:
user_text = "Sei tu l'autista!"
# Caso in cui tutti gli slot sono occupati
elif occupied_slots >= total_slots:
user_text = "Macchina piena, vai a piedi LOL. 🚶🏻♂️"
# Caso in cui lo stolto passeggero si era già prenotato
elif chat_id in trip["Temporary"] or chat_id in trip[
"Permanent"] or chat_id in trip["SuspendedUsers"]:
user_text = "Ti sei già prenotato in questa data con questa persona!"
else:
# Si attende conferma dall'autista prima di aggiungere
trip_time = trip["Time"]
slots = str(total_slots - occupied_slots - 1)
if "Location" in trip:
location = trip["Location"]
user_keyboard.insert(0, [
InlineKeyboardButton("📍 Mostra sulla mappa",
callback_data=ccd(
"SEND_LOCATION", location))
])
elif direction == "Salita":
location = "Macchinette"
else:
location = "Non definita"
driver_keyboard = [[
InlineKeyboardButton("✔ Conferma",
callback_data=ccd("ALERT_USER", "CO_BO",
direction, day, chat_id,
mode))
]]
user_text = f"Prenotazione completata. Dati del viaggio:" \
f"\n\n🚗: [{get_name(driver)}](tg://user?id={driver})" \
f"\n🗓 {day}" \
f"\n🕓 {trip_time}" \
f"\n{common.dir_name(direction)}" \
f"\n{common.mode_name(mode)}" \
f"\n📍 {location}" \
f"\n\nLa prenotazione sarà resa valida al momento della conferma dall'autista."
driver_text = "Hai una nuova prenotazione: " \
f"\n\n👤: [{get_name(chat_id)}](tg://user?id={chat_id}) " \
f"({slots} posti rimanenti)" \
f"\n🗓 {day}" \
f"\n🕓 {trip_time}" \
f"\n{common.dir_name(direction)}" \
f"\n{common.mode_name(mode)}" \
f".\n\nPer favore, conferma la presa visione della prenotazione. In caso negativo," \
f" la prenotazione verrà considerata non valida."
bot.send_message(
chat_id=driver,
text=driver_text,
reply_markup=InlineKeyboardMarkup(driver_keyboard),
parse_mode="Markdown")
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=user_text,
reply_markup=InlineKeyboardMarkup(user_keyboard),
parse_mode="Markdown")
def edit_booking(bot, update):
"""
Questo metodo viene chiamato al momento della richiesta di visione della lista delle prenotazioni da
parte dell'utente. Le prenotazione vengono prese tramite query dal metodo search_by_booking presente
in common.py. Dal menù, una volta selezionata una prenotazione, è possibile cancellarla oppure sospenderla
a lato utente, ovvero bloccarla per una settimana.
"""
chat_id = str(update.callback_query.message.chat_id)
data = separate_callback_data(update.callback_query.data)
action = data[1]
#
# Comando base chiamato dal metodo prenota. Effettua una query di tutti i viaggi presentandoli
# sottoforma di bottoni all'utente.
#
if action == "LIST":
bookings = get_bookings(chat_id)
keyboard = [[
InlineKeyboardButton("↩ Indietro",
callback_data=ccd("BOOKING_MENU"))
], [InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]]
if len(bookings) > 0:
user_keyboard = []
for item in bookings:
direction, day, driver, mode, time = item
driver_name = get_name(driver)
if is_suspended(direction, day, driver):
tag = " 🚫 Sospesa"
else:
tag = f" 🗓 {day} 🕓 {time}"
# Aggiunta del bottone
user_keyboard.append([
InlineKeyboardButton(
f"🚗 {driver_name.split(' ')[-1]}{tag}\n{common.dir_name(direction)} {common.mode_name(mode)}",
callback_data=ccd("EDIT_BOOK", "ACTION", direction,
day, driver, mode))
])
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=
"Clicca su una prenotazione per cancellarla o sospenderla.",
reply_markup=InlineKeyboardMarkup(user_keyboard + keyboard))
else:
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text="Mi dispiace, ma non hai prenotazioni all'attivo.",
reply_markup=InlineKeyboardMarkup(keyboard))
#
# Menù disponibile all'utente una volta selezionato un viaggio. I bottoni cambiano a seconda della prenotazione:
# Temporanea -> solo cancellazione
# Permanente e sospesa -> sospensione e cancellazione
#
elif action == "ACTION":
direction, day, driver, mode = data[2:]
keyboard = [
[
InlineKeyboardButton("❌ Annulla prenotazione",
callback_data=ccd("EDIT_BOOK", "DELETION",
direction, day, driver,
mode))
],
[
InlineKeyboardButton("↩ Indietro",
callback_data=ccd("EDIT_BOOK", "LIST"))
], [InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]
]
text_string = []
trip_time = get_time(direction, day, driver)
if mode == "Permanent":
keyboard.insert(0, [
InlineKeyboardButton(
"Sospendi prenotazione",
callback_data=ccd("EDIT_BOOK", "SUS_BOOK", direction, day,
driver, mode))
])
elif mode == "SuspendedUsers":
text_string.append(" - SOSPESA dall'utente")
keyboard.insert(0, [
InlineKeyboardButton(
"Annulla sospensione prenotazione",
callback_data=ccd("EDIT_BOOK", "SUS_BOOK", direction, day,
driver, mode))
])
if is_suspended(direction, day, driver):
text_string.append(" - SOSPESA dall'autista")
text_string = "".join(text_string)
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=f"Prenotazione selezionata: {text_string}\n"
f"\n🚗 [{get_name(driver)}](tg://user?id={driver})"
f"\n🗓 {day}"
f"\n{common.dir_name(direction)}"
f"\n🕓 {trip_time}"
f"\n{common.mode_name(mode)}",
reply_markup=InlineKeyboardMarkup(keyboard),
parse_mode="Markdown")
#
# SUS_BOOK = SUSPEND_BOOKING
#
elif action == "SUS_BOOK":
booking = data[2:]
mode = booking[3]
keyboard = [
InlineKeyboardButton("✔ Sì",
callback_data=ccd("EDIT_BOOK", "CO_SUS_BOOK",
*booking)),
InlineKeyboardButton("❌ No",
callback_data=ccd("EDIT_BOOK", "LIST"))
]
if mode == "Permanent":
message = "Si ricorda che la sospensione di una prenotazione è valida per una sola settimana." \
"\n\nSei sicuro di voler sospendere questo viaggio?"
elif mode == "SuspendedUsers":
message = "Vuoi rendere di nuovo operativa questa prenotazione?"
else:
message = "Errore fatale nel Bot. Contatta il creatore del bot al più presto."
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=message,
reply_markup=InlineKeyboardMarkup([keyboard]))
#
# CO_SUS_BOOK = CONFIRM_SUSPEND_BOOKING
# Il metodo scambia la chiave di un utente da Permanente a SuspendUsers e vice-versa.
#
elif action == "CO_SUS_BOOK":
direction, day, driver, mode = data[2:]
trip = get_trip(direction, day, driver)
keyboard = [[
InlineKeyboardButton("↩ Indietro",
callback_data=ccd("EDIT_BOOK", "LIST"))
], [InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]]
if mode == "Permanent":
trip["Permanent"].remove(chat_id)
trip["SuspendedUsers"].append(chat_id)
user_message = "Prenotazione sospesa. Verrà ripristinata il prossimo viaggio."
driver_message = f"[{get_name(chat_id)}](tg://user?id={chat_id})" \
f" ha sospeso la sua prenotazione permanente" \
f" per {day.lower()} {common.dir_name(direction)}."
elif mode == "SuspendedUsers":
occupied_slots = len(trip["Permanent"]) + len(trip["Temporary"])
total_slots = get_slots(driver)
if occupied_slots >= total_slots:
# Può capitare che mentre un passeggero ha reso la propria prenotazione sospesa,
# altre persone hanno preso il suo posto.
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=f"Mi dispiace, ma non puoi rendere operativa la"
f" tua prenotazione in quanto la macchina è ora piena."
f"Contatta [{get_name(driver)}](tg://user?id={driver})"
f" per risolvere la questione.",
reply_markup=InlineKeyboardMarkup(keyboard),
parse_mode="Markdown")
return
trip["Permanent"].append(chat_id)
trip["SuspendedUsers"].remove(chat_id)
user_message = "La prenotazione è di nuovo operativa."
driver_message = f"[{get_name(chat_id)}](tg://user?id={chat_id})" \
f" ha reso operativa la sua prenotazione permanente" \
f" di {day.lower()} {common.dir_name(direction)}."
else:
user_message = "Errore fatale nel Bot. Contatta il creatore del bot al più presto."
driver_message = "Errore: un tuo passeggero ha cercato di sospendere " \
"una prenotazione temporanea. Contatta il creatore del bot al più presto."
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=user_message,
reply_markup=InlineKeyboardMarkup(keyboard),
parse_mode="Markdown")
bot.send_message(chat_id=driver,
text=driver_message,
parse_mode="Markdown")
#
# Metodo per cancellare per sempre una data prenotazione.
#
elif action == "DELETION":
booking = data[2:]
keyboard = [
InlineKeyboardButton("✔ Sì",
callback_data=ccd("EDIT_BOOK", "CO_DEL",
*booking)),
InlineKeyboardButton("❌ No",
callback_data=ccd("EDIT_BOOK", "LIST"))
]
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text="Sei sicuro di voler cancellare questo viaggio?",
reply_markup=InlineKeyboardMarkup([keyboard]))
#
# CO_DEL = CONFIRM_DELETION
#
elif action == "CO_DEL":
direction, day, driver, mode = data[2:]
remove_passenger(direction, day, driver, mode, chat_id)
keyboard = [[
InlineKeyboardButton("↩ Indietro",
callback_data=ccd("EDIT_BOOK", "LIST"))
], [InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]]
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text="Prenotazione cancellata con successo.",
reply_markup=InlineKeyboardMarkup(keyboard))
bot.send_message(
chat_id=driver,
text=f"Una prenotazione al tuo viaggio è stata cancellata:"
f"\n\n👤 [{get_name(chat_id)}](tg://user?id={chat_id})"
f"\n🗓 {day}"
f"\n{common.dir_name(direction)}",
parse_mode="Markdown")
def me_handler(bot, update):
action = separate_callback_data(update.callback_query.data)[1]
chat_id = str(update.callback_query.message.chat_id)
#
# Da questo menù viene invocata la keyboard in keyboards.py.
#
if action == "TRIPS":
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text="Viaggi (clicca su un viaggio per modificarlo):",
reply_markup=trips_keyboard(chat_id))
#
# Da questo menù è possibile iscriversi e disiscriversi dalla modalità autista.
#
elif action == "DRIVER":
if is_driver(chat_id):
keyboard = [[
InlineKeyboardButton("✔ Sì",
callback_data=ccd("ME", "CO_DR_RE")),
InlineKeyboardButton("❌ No", callback_data=ccd("ME_MENU"))
]]
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text="Sei sicuro di voler confermare la tua rimozione dalla"
" lista degli autisti? Se cambiassi idea, puoi sempre iscriverti"
" di nuovo da /me. La cancellazione dal sistema comporterà il reset"
" completo di tutti i viaggi, impostazioni e crediti.",
reply_markup=InlineKeyboardMarkup(keyboard))
else:
keyboard = [[
InlineKeyboardButton("✔ Sì",
callback_data=ccd("ME", "ED_DR_SL")),
InlineKeyboardButton("❌ No", callback_data=ccd("ME_MENU"))
]]
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=
"Una volta finalizzata l'iscrizione come autista, potrai gestire i tuoi"
" viaggi direttamente da questo bot. Contatta un membro del direttivo di"
" UberNEST per ulteriori informazioni.\n\n"
"Sei sicuro di voler diventare un autista di UberNEST?",
reply_markup=InlineKeyboardMarkup(keyboard))
#
# US_RE = USER_REMOVAL
# Da questo menù è possibile attuare la cancellazione completa e totale di tutti i dati dell'utente.
# Nulla rimarrà, a parte i debiti che verranno inoltrati ai rispettivi creditori.
#
elif action == "US_RE":
keyboard = [[
InlineKeyboardButton("✔ Sì", callback_data=ccd("ME", "CO_US_RE")),
InlineKeyboardButton("❌ No", callback_data=ccd("ME_MENU"))
]]
user_debits = get_all_debits(chat_id)
debitors = []
for creditor in user_debits:
creditor_name = get_name(creditor)
debitors.append(
f" {creditor_name} - {str(user_debits[creditor])} EUR\n")
message_text = [
f"Sei sicuro di voler confermare la tua rimozione completa dal sistema?"
f" L'operazione è reversibile, ma tutte le tue prenotazioni e viaggi"
f" verranno cancellati per sempre."
]
if debitors:
message_text.append(
f"\n\nATTENZIONE! Hai debiti con le seguenti persone,"
f" in caso di cancellazione dal sistema"
f" verranno avvisate dei tuoi debiti non saldati!\n\n{''.join(debitors)}"
)
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text="".join(message_text),
reply_markup=InlineKeyboardMarkup(keyboard))
#
# ED_DR_SL = EDIT_DRIVER_SLOTS
# Questo menù permette di modificare gli slot a disposizione del guidatore.
#
elif action == "ED_DR_SL":
# Inserisco 5 bottoni per i posti con la list comprehension
keyboard = [[
InlineKeyboardButton(str(i),
callback_data=ccd("ME", "CO_DR", str(i)))
for i in range(1, 6, 1)
], [InlineKeyboardButton("↩ Indietro", callback_data=ccd("ME_MENU"))
], [InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]]
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=
"Inserisci il numero di posti disponibili nella tua macchina, autista escluso.",
reply_markup=InlineKeyboardMarkup(keyboard))
#
# CO_DR = CONFIRM_DRIVER
# Questo metodo svolge due diverse funzioni: se l'utente è un autista, è l'endpoint per la conferma
# degli slot, altrimenti dell'iscrizione
#
elif action == "CO_DR":
keyboard = [[
InlineKeyboardButton("↩ Indietro", callback_data=ccd("ME_MENU"))
], [InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]]
slots = int(separate_callback_data(update.callback_query.data)[2])
if is_driver(chat_id):
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text="Numero di posti della vettura aggiornato con successo.",
reply_markup=InlineKeyboardMarkup(keyboard))
else:
add_driver(chat_id, slots)
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=
"Sei stato inserito nella lista degli autisti! Usa il menu /me per aggiungere"
" viaggi, modificare i posti auto, aggiungere un messaggio da mostrare ai tuoi"
" passeggeri ed altro.",
reply_markup=InlineKeyboardMarkup(keyboard))
#
# CO_DR_RE = CONFIRM_DRIVER_REMOVAL
# Metodo di conferma della rimozione di un autista, vedi sopra.
#
elif action == "CO_DR_RE":
keyboard = [[
InlineKeyboardButton("↩ Indietro", callback_data=ccd("ME_MENU"))
], [InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]]
delete_driver(chat_id)
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text="Sei stato rimosso con successo dall'elenco degli autisti.",
reply_markup=InlineKeyboardMarkup(keyboard))
#
# CO_US_RE = CONFIRM_USER_REMOVAL
# Metodo di conferma rimozione utente, vedi sopra.
#
elif action == "CO_US_RE":
keyboard = [[
InlineKeyboardButton("↩ Indietro", callback_data=ccd("ME_MENU"))
], [InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]]
user_debits = get_all_debits(chat_id)
for creditor in user_debits:
bot.send_message(
chat_id=creditor,
text=f"ATTENZIONE! [{get_name(chat_id)}](tg://user?id={chat_id})"
f" si è cancellato da UberNEST. Ha ancora "
f"{str(user_debits[creditor])} EUR di debito con te.",
parse_mode="Markdown")
delete_user(chat_id)
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text="Sei stato rimosso con successo dal sistema.",
reply_markup=InlineKeyboardMarkup(keyboard))
def edit_money(bot, update):
action, user = separate_callback_data(update.callback_query.data)[1:]
chat_id = str(update.callback_query.message.chat_id)
try:
trips = str(get_single_debit(user, chat_id))
except KeyError:
set_single_debit(user, chat_id, 0)
trips = "0"
#
# Tre azioni possibili: SUBTRACT (sottrae il prezzo di un viaggio), ADD (aggiunge il prezzo
# di un viaggio), ZERO (cancella completamente il debito)
#
edit_money_keyboard = [
InlineKeyboardButton(f"+",
callback_data=ccd("EDIT_MONEY", "ADD", user)),
InlineKeyboardButton(f"-",
callback_data=ccd("EDIT_MONEY", "SUBTRACT", user))
]
if action == "SUBTRACT":
trips = quick_debit_edit(user, chat_id, "-")
user_text = f"💶 Hai saldato un viaggio con " \
f"[{get_name(chat_id)}](tg://user?id={chat_id}). " \
f"Viaggi da pagare rimanenti: {trips}."
elif action == "ADD":
trips = quick_debit_edit(user, chat_id, "+")
user_text = f"💶 [{get_name(chat_id)}](tg://user?id={chat_id})" \
f" ha aggiunto un viaggio da pagargli.\n" \
f"Viaggi da pagare rimanenti: {trips}."
elif action == "ZERO":
remove_single_debit(user, chat_id)
trips = 0
user_text = f"💸 [{get_name(chat_id)}](tg://user?id={chat_id})" \
f" ha azzerato i viaggi da pagare con te."
elif action == "NEW":
trips = 0
user_text = ""
elif action == "VIEW":
user_text = ""
else:
user_text = "Sembra che questo messaggio sia stato mandato inavvertitamente.\n" \
"Contatta il creatore del bot per segnalare il problema."
if trips != 0:
edit_money_keyboard.append(
InlineKeyboardButton("Azzera",
callback_data=ccd("EDIT_MONEY", "ZERO",
user)))
keyboard = [
edit_money_keyboard,
[InlineKeyboardButton("↩ Indietro", callback_data=ccd("MONEY"))],
[InlineKeyboardButton("🔚 Esci", callback_data=ccd("EXIT"))]
]
bot.edit_message_text(
chat_id=chat_id,
message_id=update.callback_query.message.message_id,
text=f"👤 [{get_name(user)}](tg://user?id={user})"
f"\n🚗 *{trips} {'viaggi' if trips > 1 else 'viaggio'}*",
reply_markup=InlineKeyboardMarkup(keyboard),
parse_mode="Markdown")
if action == "ADD" or action == "ZERO" or action == "SUBTRACT":
bot.send_message(chat_id=user, text=user_text, parse_mode="Markdown")