def query_to_date(update: Update, context: CallbackContext):
query: CallbackQuery = update.callback_query
period = query.data[len(prefix_to_date):]
context.chat_data['period'] = period
calendar, step = DetailedTelegramCalendar().build()
query.edit_message_text("Please, select a " + LSTEP[step],
reply_markup=calendar)
def all_messages(message):
# функция календаря, принимает мессендж
def start(m, v_string):
calendar, step = DetailedTelegramCalendar().build()
bot.send_message(m.chat.id,
f"{v_string} {LSTEP[step]}",
reply_markup=calendar)
return message.message_id
# Настройки календаря
@bot.callback_query_handler(func=DetailedTelegramCalendar.func())
def cal(c):
result, key, step = DetailedTelegramCalendar(locale='ru', min_date=d1, max_date=d2).process(c.data)
if not result and key:
bot.edit_message_text(f"Select {LSTEP[step]}",
c.message.chat.id,
c.message.message_id,
reply_markup=key)
elif result:
bot.edit_message_text(f"Min: {result.strftime('%d.%m.%Y')}",
c.message.chat.id,
c.message.message_id)
# функция построения диапазона дат от d1 до d2
def date_range(d1, d2):
return (d1 + datetime.timedelta(days=i) for i in range((d2 - d1).days + 1))
first_date = result
# вывод всех
for d in date_range(first_date, d2):
print(d.strftime('%Y.%m.%d'))
start(message, v_string='Выберите начальную дату')
async def calendar_handler(event):
result, key, step = DetailedTelegramCalendar(telethon=True, min_date=date.today()).process(event.data.decode("utf-8"))
if not result and key:
await event.edit(f"Select {LSTEP[step]}", buttons=key)
elif result:
await event.edit(f"You selected {result}")
def ask_for_date(self, update: Update, context: CallbackContext) -> None:
context.user_data[c.NEW_USER] = 0
calendar, step, = DetailedTelegramCalendar().build()
text = f'Seleziona {self.__LSTEP[step]}'
self.__editMessage(update, text, calendar)
return c.COLLECT_DATE
def send_text(message):
if message.text.lower() == 'check':
msg = bot.send_message(message.chat.id, 'Выбери настроение, которые у тебя в целом за сегодня',
reply_markup=mood_keyboard)
bot.register_next_step_handler(msg, check_today_mood)
elif message.text.lower() == 'analytics':
msg = bot.send_message(message.chat.id, 'Выбери интервал, за который AI будет анализировать данные',
reply_markup=interval_keyboard)
bot.register_next_step_handler(msg, get_interval)
elif message.text.lower() == 'check old':
calendar, step = DetailedTelegramCalendar(max_date=date.today()).build()
bot.send_message(message.chat.id, f"Select {LSTEP[step]}", reply_markup=calendar)
msg = bot.send_message(message.chat.id, 'Выбери СНАЧАЛА ДАТУ, потом настроение, которые было в тот день',
reply_markup=mood_keyboard)
bot.register_next_step_handler(msg, check_old_mood)
elif message.text.lower() == 'menu':
bot.send_message(message.chat.id, 'Choose action', reply_markup=menu_keyboard)
elif message.text == 'Гюнель, 22 года, юрист':
bot.send_message(message.chat.id,
'''
Гюнель:
Привет, меня зовут Гюнель, я юрист, закончила бакалавр МГЮА без 4... и 3 и 2 тоже не было.
Сейчас я работаю в юридическое конторе и учусь на магистратуре. Еще я учу английский. В общем, обычная жизнь молодой, красивой, современной и успешной леди.
Но все же раньше я думала, что моя жизнь не очень веселая, но в какой-то момент мне попался билборд с рекламой бота MoodCheckingBot, я подумала:
- А че, можно попробовать.
Вы знаете, после того, как я начала пользоваться ботом, моя жизнь поделилась на "до" и "после".
Я наконец-то поняла, что моя жизнь очень веселая.
Когда же у меня неделю плохое настроение, при помощи бота я сразу это понимаю и тут же беру отпуск и улетаю на Бали.
А когда настроение не очень 3 недели, я просто меняю работу, все просто! Все просто с ботом MoodCheckingBot!
''', reply_markup=menu_keyboard)
def start2(m):
# do not forget to put calendar_id
calendar, step = DetailedTelegramCalendar(calendar_id=2,
locale='ru').build()
bot.send_message(m.chat.id,
f"Calendar 2: Select {LSTEP[step]}",
reply_markup=calendar)
def date_handler(self, update: Update, context: CallbackContext) -> None:
query = update.callback_query
querydata = query.data
result, key, step = DetailedTelegramCalendar().process(querydata)
# scelta anno, mese, giorno
if not result and key:
text = f'Seleziona {self.__LSTEP[step]}'
keyboard = key
self.__editMessage(update, text, keyboard)
return c.COLLECT_DATE
# strada intrapresa dopo la scelta del giorno
else:
res = str(result) # data scelta dall'utente = str(result)
parsedRes = date_parser.dateParser(res)
context.user_data[c.MONTH] = parsedRes[0]
context.user_data[c.DAY] = parsedRes[1]
text = f"Hai selezionato {result} \n Dimmi cosa fare👇"
keyboard = keyboards.dateConfirmationKeyboard
self.__editMessage(update, text, keyboard)
return c.COLLECT_HALL_INFO
def cal(c):
result, key, step = DetailedTelegramCalendar(locale='ru',
calendar_id=2).process(c.data)
if not result and key:
bot.edit_message_text(f"Выберите конец периода",
c.message.chat.id,
c.message.message_id,
reply_markup=key)
elif result:
bot.edit_message_text(f"Конец периода: {result}", c.message.chat.id,
c.message.message_id)
finish_date = result.strftime("%Y.%m.%d")
group_id = bk.output(c.message.chat.id)
global start_date
s = bk.get_schedule(str(group_id), start_date, finish_date)
bot.send_message(c.message.chat.id, s)
def query_to_result(update: Update, context: CallbackContext):
query: CallbackQuery = update.callback_query
date, key, step = DetailedTelegramCalendar().process(query.data)
if not date and key:
query.edit_message_text(f"Please, select {LSTEP[step]}",
reply_markup=key)
return
if date is None:
return
datetime_now = datetime.datetime.now()
if date < datetime_now.date():
context.bot.answer_callback_query(query.id,
"Start date cannot be in the past.",
show_alert=True)
return
elif date > add_one_month(datetime_now).date():
context.bot.answer_callback_query(
query.id,
"Start date should be more than one month from now.",
show_alert=True)
return
period = context.chat_data['period']
msg = context.chat_data['scheduled_msg']
message = ScheduledMessage(
msg, period,
datetime.datetime.combine(date, update.effective_message.date.time()))
context.bot_data['db'].add_scheduled_message(update.effective_chat.id,
message)
run_job(context.job_queue, message, update.effective_chat.id)
query.edit_message_text("Done. Message successfully scheduled")
def start(m, v_string):
calendar, step = DetailedTelegramCalendar().build()
bot.send_message(m.chat.id,
f"{v_string} {LSTEP[step]}",
reply_markup=calendar)
return message.message_id
def cal(c):
result, key, step = DetailedTelegramCalendar(locale='ru',
calendar_id=1).process(c.data)
if not result and key:
bot.edit_message_text(f"Выберите начало периода",
c.message.chat.id,
c.message.message_id,
reply_markup=key)
elif result:
bot.edit_message_text(f"Начало периода: {result}", c.message.chat.id,
c.message.message_id)
global start_date
start_date = result.strftime("%Y.%m.%d")
calendar, step = DetailedTelegramCalendar(locale='ru',
calendar_id=2).build()
bot.send_message(c.message.chat.id,
f"Выберите конец периода",
reply_markup=calendar)
def cal(c):
result, key, step = DetailedTelegramCalendar(max_date=date.today()).process(c.data)
if not result and key:
bot.edit_message_text(f"Select {LSTEP[step]}",
c.message.chat.id,
c.message.message_id,
reply_markup=key)
elif result:
global update_dt
update_dt = result
def cal(c):
result, key, step = DetailedTelegramCalendar().process(c.data)
if not result and key:
bot.edit_message_text(f"Select {LSTEP[step]}",
c.message.chat.id,
c.message.message_id,
reply_markup=key)
elif result:
bot.edit_message_text(f"You selected {result}", c.message.chat.id,
c.message.message_id)
def cal1(c):
# calendar_id is used here too, since the new keyboard is made
result, key, step = DetailedTelegramCalendar(calendar_id=1).process(c.data)
if not result and key:
bot.edit_message_text(f"Calendar 1: Select {LSTEP[step]}",
c.message.chat.id,
c.message.message_id,
reply_markup=key)
elif result:
bot.edit_message_text(f"You selected {result} in calendar 1",
c.message.chat.id, c.message.message_id)
def cal(c):
result, key, step = DetailedTelegramCalendar().process(c.data)
if not result and key:
bot.edit_message_text(f"Select {LSTEP[step]}",
c.message.chat.id,
c.message.message_id,
reply_markup=key)
elif result:
bot.edit_message_text(
f"Ты выбрал {result}, теперь пора выбрать наш маршрут НАПИШИ /city ",
c.message.chat.id, c.message.message_id)
async def inline_kb_answer_callback_handler(query):
result, key, step = DetailedTelegramCalendar().process(query.data)
if not result and key:
await bot.edit_message_text(f"Select {LSTEP[step]}",
query.message.chat.id,
query.message.message_id,
reply_markup=key)
elif result:
await bot.edit_message_text(f"You selected {result}",
query.message.chat.id,
query.message.message_id)
def start(m):
user_dict = {}
chat_id = m.chat.id
try:
calendar, step = DetailedTelegramCalendar(
min_date=datetime.date.today()).build()
bot.send_message(m.chat.id,
f"Select {LSTEP[step]}",
reply_markup=calendar)
except KeyError:
bot.send_message(
chat_id,
f"You will need a name to book a slot. Please press /start to input your name."
)
def in_date(message):
# функция календаря, принимает мессендж
def start(m, v_string):
calendar, step = DetailedTelegramCalendar().build()
bot.send_message(m.chat.id,
f"{v_string} {LSTEP[step]}",
reply_markup=calendar)
return message.message_id
# Настройки календаря
@bot.callback_query_handler(func=DetailedTelegramCalendar.func())
def cal(c):
result, key, step = DetailedTelegramCalendar(locale='ru', min_date=d1, max_date=d2).process(c.data)
if not result and key:
bot.edit_message_text(f"Select {LSTEP[step]}",
c.message.chat.id,
c.message.message_id,
reply_markup=key)
elif result:
bot.edit_message_text(f"Min: {result.strftime('%d.%m.%Y')}",
c.message.chat.id,
c.message.message_id)
# функция построения диапазона дат от d1 до d2
def date_range(d1, d2):
return (d1 + datetime.timedelta(days=i) for i in range((d2 - d1).days + 1))
first_date = result
# вывод всех
for d in date_range(first_date, d2):
print(d.strftime('%Y.%m.%d'))
markup = telebot.types.InlineKeyboardMarkup()
button = telebot.types.InlineKeyboardButton(text='Выбрать начало', callback_data='first_date')
markup.add(button)
button = telebot.types.InlineKeyboardButton(text='Выбрать конец', callback_data='second_date')
markup.add(button)
bot.send_message(chat_id=message.chat.id, text='Выберите начальную и конечную даты', reply_markup=markup)
@bot.callback_query_handler(func=lambda call: True)
def query_handler(call):
if call.data == 'first_date':
bot.answer_callback_query(callback_query_id=call.id, text='Hello world')
start(message, v_string='Выберите начальную дату')
if call.data == 'second_date':
bot.answer_callback_query(callback_query_id=call.id, text='Sad world')
def cal(c):
result, key, step = DetailedTelegramCalendar(
min_date=datetime.date.today()).process(c.data)
if not result and key:
bot.edit_message_text(f"Select {LSTEP[step]}",
c.message.chat.id,
c.message.message_id,
reply_markup=key)
elif result:
isDuplicate = checkDuplicate(c.message.chat.id, result)
if isDuplicate:
bot.edit_message_text(
f"Your have already requested for a slot on {result}.",
c.message.chat.id, c.message.message_id)
else:
user_dict['dateSpecified'] = result
msg = bot.edit_message_text(
f"Please type your reason for returning to office on the {result}.",
c.message.chat.id, c.message.message_id)
bot.register_next_step_handler(msg, process_reason_step)
def cal(c):
result, key, step = DetailedTelegramCalendar(locale='ru', min_date=d1, max_date=d2).process(c.data)
if not result and key:
bot.edit_message_text(f"Select {LSTEP[step]}",
c.message.chat.id,
c.message.message_id,
reply_markup=key)
elif result:
bot.edit_message_text(f"Min: {result.strftime('%d.%m.%Y')}",
c.message.chat.id,
c.message.message_id)
# функция построения диапазона дат от d1 до d2
def date_range(d1, d2):
return (d1 + datetime.timedelta(days=i) for i in range((d2 - d1).days + 1))
first_date = result
# вывод всех
for d in date_range(first_date, d2):
print(d.strftime('%Y.%m.%d'))
def check_old_mood(message):
print('check_old_mood')
if message.text.lower() in mood_list:
#выбрана дата, потом статус
try:
user_id = message.from_user.id
global dt
dt = update_dt
status = mood_dict[message.text.lower()]
conn = sqlite3.connect('mood.db')
cur = conn.cursor()
if check_recording(user_id, dt) == 'insert':
cur.execute(f'''
INSERT INTO mood_status(userid, date, status)
VALUES({user_id}, '{dt}', '{status}')
''')
conn.commit()
msg = bot.send_message(message.chat.id, 'Напиши комментарий', reply_markup=comment_keyboard)
bot.register_next_step_handler(msg, add_commentary)
else:
cur.execute(f'''
update mood_status
set status = '{status}'
where userid = {user_id}
and date = '{dt}'
''')
conn.commit()
msg = bot.send_message(message.chat.id, 'Напиши комментарий', reply_markup=comment_keyboard)
bot.register_next_step_handler(msg, add_commentary)
except:
calendar, step = DetailedTelegramCalendar(max_date=date.today()).build()
bot.send_message(message.chat.id, f"Select {LSTEP[step]}", reply_markup=calendar)
msg = bot.send_message(message.chat.id,
'''Не так, выбери СНАЧАЛА ДАТУ, потом настроение, которое было в тот день, ван мо трай''',
reply_markup=mood_keyboard)
bot.register_next_step_handler(msg, check_old_mood)
'C:/Users/sergey/PycharmProjects/pythonProject2/telegram/static/sticker.webp',
'rb')
bot.send_sticker(message.chat.id, img)
bot.reply_to(
message,
f"Привет, сейчас я предложу выбрать дату поездки. Для этого НАПИШИ /date, "
f"{message.from_user.first_name}")
@bot.message_handler(commands=['date'])
def start(m):
calendar, step = DetailedTelegramCalendar().build()
bot.send_message(m.chat.id, f"Select {LSTEP[step]}", reply_markup=calendar)
@bot.callback_query_handler(func=DetailedTelegramCalendar.func())
def cal(c):
result, key, step = DetailedTelegramCalendar().process(c.data)
if not result and key:
bot.edit_message_text(f"Select {LSTEP[step]}",
c.message.chat.id,
c.message.message_id,
reply_markup=key)
elif result:
bot.edit_message_text(
f"Ты выбрал {result}, теперь пора выбрать наш маршрут НАПИШИ /city ",
c.message.chat.id, c.message.message_id)
start_city = ''
end_city = ''
async def run_dt(event): # запуск выбора времени даты
calendar, step = DetailedTelegramCalendar(telethon=True, min_date=date.today()).build()
await event.respond(f"Select {LSTEP[step]}", buttons=calendar)
bot.send_message(m.chat.id,
f"Calendar 1: Select {LSTEP[step]}",
reply_markup=calendar)
@bot.message_handler(commands=['start2'])
def start2(m):
# do not forget to put calendar_id
calendar, step = DetailedTelegramCalendar(calendar_id=2,
locale='ru').build()
bot.send_message(m.chat.id,
f"Calendar 2: Select {LSTEP[step]}",
reply_markup=calendar)
@bot.callback_query_handler(func=DetailedTelegramCalendar.func(calendar_id=1))
def cal1(c):
# calendar_id is used here too, since the new keyboard is made
result, key, step = DetailedTelegramCalendar(calendar_id=1).process(c.data)
if not result and key:
bot.edit_message_text(f"Calendar 1: Select {LSTEP[step]}",
c.message.chat.id,
c.message.message_id,
reply_markup=key)
elif result:
bot.edit_message_text(f"You selected {result} in calendar 1",
c.message.chat.id, c.message.message_id)
@bot.callback_query_handler(func=DetailedTelegramCalendar.func(calendar_id=2))
def cal1(c):
api_id = 123456
api_hash = "1233456789"
bot_token = '1219481769:AAFrlaSczx4xa0OtsBGp51dESfNmoJrH6zg'
bot = TelegramClient("bot", api_id, api_hash)
class MyStyleCalendar(DetailedTelegramCalendar):
empty_month_button = ""
empty_year_button = ""
@bot.on(events.NewMessage(pattern="/start"))
async def reply_handler(event):
calendar, step = DetailedTelegramCalendar(telethon=True, min_date=date.today()).build()
await event.respond(f"Select {LSTEP[step]}", buttons=calendar)
@bot.on(events.CallbackQuery(pattern=DetailedTelegramCalendar.func(telethon=True)))
async def calendar_handler(event):
result, key, step = DetailedTelegramCalendar(telethon=True, min_date=date.today()).process(event.data.decode("utf-8"))
if not result and key:
await event.edit(f"Select {LSTEP[step]}", buttons=key)
elif result:
await event.edit(f"You selected {result}")
bot.start(bot_token=bot_token)
with bot:
bot.run_until_disconnected()
async def reply_handler(event):
calendar, step = DetailedTelegramCalendar(telethon=True, min_date=date.today()).build()
await event.respond(f"Select {LSTEP[step]}", buttons=calendar)
def start(m):
calendar, step = DetailedTelegramCalendar().build()
bot.send_message(m.chat.id, f"Select {LSTEP[step]}", reply_markup=calendar)
def start(m):
calendar, step = DetailedTelegramCalendar(locale='ru',
calendar_id=1).build()
bot.send_message(m.chat.id,
f"Выберите начало периода",
reply_markup=calendar)
from telegram_bot_calendar import DetailedTelegramCalendar, LSTEP
bot = Bot(token="token")
dp = Dispatcher(bot)
@dp.message_handler(commands='start')
async def start(message):
calendar, step = DetailedTelegramCalendar().build()
await bot.send_message(message.chat.id,
f"Select {LSTEP[step]}",
reply_markup=calendar)
@dp.callback_query_handler(DetailedTelegramCalendar.func())
async def inline_kb_answer_callback_handler(query):
result, key, step = DetailedTelegramCalendar().process(query.data)
if not result and key:
await bot.edit_message_text(f"Select {LSTEP[step]}",
query.message.chat.id,
query.message.message_id,
reply_markup=key)
elif result:
await bot.edit_message_text(f"You selected {result}",
query.message.chat.id,
query.message.message_id)
executor.start_polling(dp, skip_updates=True)
def main():
# Create the Updater and pass it your bot's token.
TOKEN = "your token here"
bot = SbaBot(TOKEN)
# Set up third level ConversationHandler (collecting sub/booking features)
add_user_to_database = ConversationHandler(
entry_points=[CallbackQueryHandler(bot.update_database, pattern='^' + str(c.COMPLETE_SUB) + '$')],
states={
c.MODIFY_DATA: [CallbackQueryHandler(bot.modify_user_data, pattern='^' + str(c.MODIFY) + '$')],
c.END: [bot.end]
},
fallbacks=[CallbackQueryHandler(bot.back_to_main_menu, pattern='^' + str(c.BACK) + '$'),
CommandHandler('stop', bot.stop_nested),
],
map_to_parent={
c.BACK: c.BACK,
c.STOPPING: c.STOPPING,
},
)
delete_user_from_db = ConversationHandler(
entry_points=[MessageHandler(Filters.text & ~Filters.command, bot.delete_user)],
states={
c.DELETE_USER: [CallbackQueryHandler(bot.id_to_delete, pattern='^' + str(c.DELETE_SUB) + '$')],
},
fallbacks=[
# CallbackQueryHandler(bot.back_to_main_menu, pattern='^' + str(c.BACK) + '$'),
# CommandHandler('stop', bot.stop_nested),
],
map_to_parent={
c.DELETE_USER: c.DELETE_USER,
c.END: c.END,
c.STOPPING: c.END,
},
)
# Set up second level ConversationHandler (sub to Sba Autofiller)
collect_user_data = ConversationHandler(
entry_points=[CallbackQueryHandler(bot.hall_confirmation, pattern='[0-9]+$')],
states={
c.COLLECT_NAME: [CallbackQueryHandler(bot.ask_for_name, pattern='^' + str(c.CONFIRM_HALL) + '$')],
c.COLLECT_EMAIL: [MessageHandler(Filters.text & ~Filters.command, bot.ask_for_email)],
c.COLLECT_ID: [MessageHandler(Filters.text & ~Filters.command, bot.ask_for_id)],
c.COLLECT_PHONE: [MessageHandler(Filters.text & ~Filters.command, bot.ask_for_phone)],
c.DATA_CONFIRMATION: [MessageHandler(Filters.text & ~Filters.command, bot.confirm_data)],
c.ADD_USER_TO_DATABASE: [add_user_to_database],
c.BOOKING_CONFIRMATION: [CallbackQueryHandler(bot.reserve_seat, pattern='^' + str(c.BOOK) + '$')],
},
fallbacks=[
CallbackQueryHandler(bot.back_to_main_menu, pattern='^' + str(c.BACK) + '$'),
CallbackQueryHandler(bot.autofiller_options, pattern='^' + str(c.SUB_MENU) + '$'),
# CallbackQueryHandler(bot.autofiller_options, pattern='^' + str(c.RESTART) + '$'),
CallbackQueryHandler(bot.ask_for_hall, pattern='^' + str(c.CHANGE_HALL) + '$'),
CallbackQueryHandler(bot.ask_for_name, pattern='^' + str(c.CONFIRM_HALL) + '$'),
CommandHandler('stop', bot.stop_nested),
],
map_to_parent={
# Return to top level menu
c.END: c.COLLECT_HALL_INFO,
# End conversation alltogether
c.SELECTING_OPTION: c.SELECTING_OPTION,
c.STOPPING: c.END,
c.COLLECT_HALL_INFO: c.COLLECT_HALL_INFO,
c.COLLECT_USER_DATA: c.COLLECT_USER_DATA,
},
)
# Set up top level ConversationHandler (selecting main command)
# Because the states of the third level conversation map to the ones of the second level
# conversation, we need to make sure the top level conversation can also handle them
user_info_handlers = [
collect_user_data,
]
delete_user_handlers = [
delete_user_from_db,
]
conv_handler = ConversationHandler(
entry_points=[CommandHandler('start', bot.start)],
states={
c.SELECTING_OPTION: [
CallbackQueryHandler(bot.autofiller_options, pattern='^' + str(c.SUB) + '$'),
CallbackQueryHandler(bot.ask_for_date, pattern='^' + str(c.BOOK) + '$'),
CallbackQueryHandler(bot.id_to_delete, pattern='^' + str(c.DELETE_SUB) + '$'),
CallbackQueryHandler(bot.end, pattern='^' + str(c.END) + '$'),
CallbackQueryHandler(bot.get_user_info, pattern='^' + str(c.SHOW_INFO) + '$')
],
c.COLLECT_HALL_INFO: [CallbackQueryHandler(bot.ask_for_hall,
pattern='^' + str(c.MODIFY) + '$|^' + str(
c.NEW_SUB) + '$|^' + str(c.SELF_SUB) + '$|^' + str(
c.COLLECT_HALL_INFO) + '$')],
c.COLLECT_USER_DATA: user_info_handlers,
c.COLLECT_DATE: [CallbackQueryHandler(bot.date_handler, DetailedTelegramCalendar().func())],
c.DELETE_USER: delete_user_handlers,
c.STOPPING: [CommandHandler('start', bot.start)],
},
fallbacks=[CommandHandler('stop', bot.stop_bot),
CallbackQueryHandler(bot.autofiller_options, pattern='^' + str(c.SUB) + '$'),
CallbackQueryHandler(bot.ask_for_hall, pattern='^' + str(c.MODIFY) + '$'),
CallbackQueryHandler(bot.end, pattern='^' + str(c.END) + '$'),
CallbackQueryHandler(bot.back_to_main_menu, pattern='^' + str(c.BACK) + '$'),
CallbackQueryHandler(bot.ask_for_date, pattern='^' + str(c.BOOK) + '$'),
]
)
bot.dispatcher.add_handler(conv_handler)
bot.updater.start_polling()
bot.updater.idle()