Изменена структурапроекта

изменены все кнопки на call-back
Уменьшено количество обращений к бд

bot/__init__.py

@@ -3,3 +3,4 @@ import bot.config
 import bot.functions
 import bot.keyboards
 import bot.dispatcher
+import bot.states

bot/config.py

@@ -14,4 +14,5 @@ DB_PASS = os.getenv('DB_PASS')
 CHAT_ID = os.getenv('CHAT_ID')
 SSH_HOST = os.getenv('SSH_HOST')
 SSH_USER = os.getenv('SSH_USER')
-SSH_PASS = os.getenv('SSH_PASS')
+SSH_PASS = os.getenv('SSH_PASS')
+TRASH_CHAT = os.getenv('TRASH_CHAT')

bot/database.py

@@ -50,7 +50,6 @@ class Database:
     def sql_query_send(self, sql: str):
         self.execute(sql)
         self.commit()
-        self.close()
 
     def sql_parse_users(self, sql: str):
         self.execute(sql)

bot/functions.py

@@ -162,7 +162,7 @@ def check_overlap(start, end, date):
     for time in times:
         it.addi(time['e_start'], time['e_end'])
 
-    print(it.overlaps(start, end))
+    # print(it.overlaps(start, end))
     return not it.overlaps(start, end)
 
 

bot/keyboards.py

@@ -1,55 +1,44 @@
-from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton, ReplyKeyboardMarkup, KeyboardButton
+from aiogram.types import InlineKeyboardMarkup, InlineKeyboardButton
 from bot.functions import month_text
 
+
 # Основная
-button_bind = KeyboardButton('🎯 Запланировать мероприятие')
-button_my = KeyboardButton('🗒 Мои события')
-button_all = KeyboardButton('📅 Все события')
-button_config = KeyboardButton("👮 Управление")
-main_kb = ReplyKeyboardMarkup(resize_keyboard=True)
-
-main_kb.add(button_bind, button_config)
-main_kb.add(button_my, button_all)
-
-# регистрация
-register_kb = ReplyKeyboardMarkup(resize_keyboard=True)
-button_register = KeyboardButton('Зарегистрироваться')
-register_kb.add(button_register)
-
-# отмена регистрации
-reset_register_kb = ReplyKeyboardMarkup(resize_keyboard=True)
-res_button = KeyboardButton("Отменить регистрацию")
-reset_register_kb.add(res_button)
-
-# Проверка статуса регистрации
-check_register_kb = ReplyKeyboardMarkup(resize_keyboard=True)
-check_button = KeyboardButton("Проверить статус заявки")
-check_register_kb.add(check_button)
-
-
-# Для администраторов
-admin_keyboard = ReplyKeyboardMarkup(resize_keyboard=True)
-waiting_users = KeyboardButton("👤 Управление пользователями")
-waiting_events = KeyboardButton("🎫 Управление мероприятиями")
-back = KeyboardButton("Выйти")
-admin_keyboard.add(waiting_events, waiting_users)
-admin_keyboard.add(back)
-
-
-# Клавиатура для заявок
-def manage_kb(b_accept, b_deny, b_next, b_prev, b_count):
+def main_kb():
+    keyboard = InlineKeyboardMarkup()
+    plain = InlineKeyboardButton(text='🎯 Запланировать мероприятие', callback_data='plain')
+    my_events = InlineKeyboardButton(text='🗒 Мои события', callback_data='my_events')
+    all_events = InlineKeyboardButton(text='📅 Все события', callback_data='all_events')
+    manage = InlineKeyboardButton(text='👮 Управление', callback_data='manage')
+    keyboard.add(plain)
+    keyboard.add(my_events)
+    keyboard.add(all_events)
+    # keyboard.add(manage)
+    return keyboard
+
+
+def register_kb():
+    keyboard = InlineKeyboardMarkup()
+    register = InlineKeyboardButton("Регистрация", callback_data="register")
+    keyboard.add(register)
+    return keyboard
+
+
+def reset_register_kb():
+    keyboard = InlineKeyboardMarkup()
+    reset = InlineKeyboardButton("Отменить регистрацию", callback_data="res_register")
+    keyboard.add(reset)
+    return keyboard
+
+
+def new_user_kb(accept, deny, u_id):
     keyboard = InlineKeyboardMarkup()
-    accept_button = InlineKeyboardButton(text="Одобрить", callback_data=b_accept)
-    deny_button = InlineKeyboardButton(text="Отклонить", callback_data=b_deny)
-    count_button = InlineKeyboardButton(text=b_count, callback_data="NULL")
-    next_button = InlineKeyboardButton(text="Далее", callback_data=b_next)
-    prev_button = InlineKeyboardButton(text="Назад", callback_data=b_prev)
-
-    keyboard.add(accept_button, deny_button)
-    keyboard.add(prev_button, count_button, next_button)
+    accept = InlineKeyboardButton("Одобрить", callback_data=f"{accept}:{u_id}")
+    deny = InlineKeyboardButton("Отклонить", callback_data=f"{deny}:{u_id}")
+    keyboard.add(accept, deny)
     return keyboard
 
 
+
 def events_range_kb():
     keyboard = InlineKeyboardMarkup()
     today_button = InlineKeyboardButton(text="За сегодня", callback_data="today")
@@ -69,20 +58,21 @@ def cancel_booking():
 def events_kb():
     keyboard = InlineKeyboardMarkup()
     booking_button = InlineKeyboardButton(text='Забронировать', callback_data="booking")
-    back_button = InlineKeyboardButton(text='Отменить', callback_data="change")
+    back_button = InlineKeyboardButton(text='Отменить', callback_data="cancel_booking")
     keyboard.add(back_button, booking_button)
     return keyboard
 
 
 # Генератор календаря
 def make_calendar(month, days_in_month, m_prev, m_next):
-    mont_text = InlineKeyboardButton(text=month_text(month-1), callback_data='NULL')
+    mont_text = InlineKeyboardButton(text=month_text(month - 1), callback_data='NULL')
     keyboard = InlineKeyboardMarkup(row_width=7)
     prev_month = InlineKeyboardButton(text="<<", callback_data=m_prev)
     next_month = InlineKeyboardButton(text=">>", callback_data=m_next)
+    cancel_button = InlineKeyboardButton(text="Отменить", callback_data="cancel_booking")
 
     keyboard.row_width = 7
-    for i in range(1, days_in_month+1, 1):
+    for i in range(1, days_in_month + 1, 1):
         if i < 10:
             day = f"0{i}"
         else:
@@ -90,6 +80,7 @@ def make_calendar(month, days_in_month, m_prev, m_next):
         date_i = InlineKeyboardButton(text=str(i), callback_data=f"date_2022-{str(month)}-{str(day)}")
         keyboard.insert(date_i)
 
-    keyboard.add(mont_text)
-    keyboard.add(prev_month, next_month)
+    keyboard.add(prev_month, mont_text, next_month)
+    keyboard.add()
+    keyboard.add(cancel_button)
     return keyboard

bot/messages.py

@@ -1,22 +0,0 @@
-# Для форматирования сообщений
-
-non_register = "Команды станут доступны после регистрации"
-
-
-def events_welcome(data):
-    text = (f"выберите дату чтобы увидеть список мероприятий\n\n"
-            f"Так же календарь мероприятий можно посмотреть в "
-            f"<a href=moodle.tomtit-tomsk.ru>Moodle</a>\n\n"
-            f"Сегодняшняя дата <b>{data}</b>")
-    return text
-
-
-def select_date_empty(data):
-    pass
-
-
-def select_date():
-    pass
-
-
-

bot/notifications.py

@@ -0,0 +1,55 @@
+from datetime import datetime
+
+from bot.dispatcher import bot
+import bot.config as cnf
+from bot.keyboards import new_user_kb
+
+
+async def new_bug(data):
+    msg = f"<b>Обратная связь</b>\n" \
+          f"Сообщение: {data['bug']}\n" \
+          f"Отправитель: @{data['from_user']}\n"
+    await bot.send_message(cnf.TRASH_CHAT, msg)
+
+
+async def new_user(data):
+    msg = f"<b>Новый пользователь</b>\n" \
+          f"TG: @{data['tg']}\n" \
+          f"ФИО: {data['FIO']}\n" \
+          f"Номер телефона: {data['number']}"
+    await bot.send_message(cnf.TRASH_CHAT, msg, reply_markup=new_user_kb(f"u_accept", f"u_deny", data['id']))
+
+
+async def new_event(data):
+    msg = f"<b>Новая заявка мероприятия</b>\n\n" \
+          f"Дата: {data['date']}\n" \
+          f"ФИО: {data['username']}\n" \
+          f"C {data['t_start']} до {data['t_end']}\n" \
+          f"Описание {data['description']}"
+    await bot.send_message(cnf.TRASH_CHAT, msg, reply_markup=new_user_kb(f"e_accept", f"e_deny", data['id']))
+
+
+async def notify_user_reg_accept(u_id):
+    msg = f"Учетная запись подтверждена"
+    await bot.send_message(u_id, msg)
+
+
+async def notify_user_reg_deny(u_id):
+    msg = f"Учетная запись отклонена"
+    await bot.send_message(u_id, msg)
+
+
+async def notify_user_event_accept(u_id):
+    msg = f"Заявка мероприятия одобрена"
+    await bot.send_message(u_id, msg)
+
+
+async def notify_user_event_deny(u_id):
+    msg = f"Заявка мероприятия отклонена"
+    await bot.send_message(u_id, msg)
+
+
+async def trash_msg(msg, user):
+    msg = f"User: @{user}\n" \
+          f"Msg: {msg}"
+    await bot.send_message(cnf.TRASH_CHAT, msg)

handlers/__init__.py

@@ -1,6 +1,3 @@
-import handlers.admin.admin_menu
-import handlers.admin.manage_users
-import handlers.admin.manage_events
-import handlers.user.registration
 import handlers.start
-import handlers.user.make_events
+import handlers.admin
+import handlers.user

handlers/admin/__init__.py

@@ -1,4 +1,4 @@
-import handlers.admin.admin_menu
-import handlers.admin.manage_users
-import handlers.admin.manage_events
-import handlers.admin.notifications
+import handlers.admin.accept_event
+import handlers.admin.accept_user
+import handlers.admin.deny_user
+import handlers.admin.deny_event

handlers/admin/accept_event.py

@@ -0,0 +1,16 @@
+from aiogram import types, Dispatcher
+from bot import database
+from bot.notifications import notify_user_event_accept
+
+
+async def accept_event(call: types.CallbackQuery):
+    db = database.Database()
+    t_id = call.data.split(":")[1]
+    client_id = db.sql_fetchone(f"select owner from events_table where id = {t_id}")
+    db.sql_query_send(f"update events_table set approved = '1' where id = {t_id}")
+    await call.message.edit_text("Заявка одобрена")
+    await notify_user_event_accept(client_id)
+
+
+def register(dp: Dispatcher):
+    dp.register_callback_query_handler(accept_event, text_startswith='e_accept:')

handlers/admin/accept_user.py

@@ -0,0 +1,19 @@
+from aiogram import types, Dispatcher
+from bot import database
+from bot.notifications import notify_user_reg_accept
+
+
+async def accept_user(call: types.CallbackQuery):
+    # print(call.data)
+    u_id = call.data.split(":")[1]
+
+    db = database.Database()
+    username = db.sql_fetchone(f"select name from user_table where tg_id = {call.from_user.id}")
+    await call.message.edit_text(f"{username} подтвердил учетную запись\n"
+                                 f"")
+    db.sql_query_send(f"update user_table set approved ='1' where tg_id = {u_id}")
+    await notify_user_reg_accept(u_id)
+
+
+def register(dp: Dispatcher):
+    dp.register_callback_query_handler(accept_user, text_startswith='u_accept:')

handlers/admin/admin_menu.py

@@ -1,34 +0,0 @@
-from aiogram import types, Dispatcher
-from bot.keyboards import register_kb, main_kb, admin_keyboard
-from bot import database
-
-
-async def enter_admin_menu(message: types.message):
-    db = database.Database()
-    if not db.sql_fetchone(sql=f"select tg_id from user_table where tg_id ={message.from_user.id}") or \
-            not db.sql_fetchone(sql=f"select approved from user_table where tg_id={message.from_user.id}"):
-        await message.delete()
-        await message.answer("Команды станут доступны после регистрации", reply_markup=register_kb)
-    if db.sql_fetchone(sql=f'select admin from user_table where tg_id = {message.from_user.id}') == "0":
-        await message.answer("Доступ только для администраторов")
-    else:
-        await message.delete()
-        await message.answer(f"Панель управления лакеем\n\n"
-                             f"Здесь вы можете управлять заявками", reply_markup=admin_keyboard)
-
-
-async def exit_admin_menu(message: types.message):
-    db = database.Database()
-    if not db.sql_fetchone(sql=f"select tg_id from user_table where tg_id ={message.from_user.id}") or \
-            not db.sql_fetchone(sql=f"select approved from user_table where tg_id={message.from_user.id}"):
-        await message.delete()
-        await message.answer("Команды станут доступны после регистрации", reply_markup=register_kb)
-    elif not db.sql_fetchone(sql=f'select admin from user_table where tg_id = {message.from_user.id}'):
-        await message.answer("Доступ только для администраторов", reply_markup=main_kb)
-    else:
-        await message.answer("Выход", reply_markup=main_kb)
-
-
-def register_admin_menu(dp: Dispatcher):
-    dp.register_message_handler(enter_admin_menu, text="👮 Управление")
-    dp.register_message_handler(exit_admin_menu, text="Выйти")

handlers/admin/deny_event.py

@@ -0,0 +1,17 @@
+from aiogram import types, Dispatcher
+from bot import database
+from bot.notifications import notify_user_event_deny
+
+
+async def deny_event(call: types.CallbackQuery):
+    db = database.Database()
+    t_id = call.data.split(":")[1]
+    client_id = db.sql_fetchone(f"select owner from events_table where id = {t_id}")
+    db.sql_query_send(f"delete from events_table where id = {t_id}")
+    db.sql_query_send(f"ALTER TABLE events_table  AUTO_INCREMENT={int(t_id)-1};")
+    await call.message.edit_text("Мероприятие отклонено")
+    await notify_user_event_deny(client_id)
+
+
+def register(dp: Dispatcher):
+    dp.register_callback_query_handler(deny_event, text_startswith='e_deny:')

handlers/admin/deny_user.py

@@ -0,0 +1,17 @@
+from aiogram import types, Dispatcher
+from bot import database
+from bot.notifications import notify_user_reg_deny
+
+
+async def deny_user(call: types.CallbackQuery):
+    u_id = call.data.split(":")[1]
+    db = database.Database()
+    username = db.sql_fetchone(f"select name from user_table where tg_id = {call.from_user.id}")
+    # db.sql_query_send(f"update")
+    await call.message.edit_text(f"{username} отклонил учетную запись\n"
+                                 f"")
+    await notify_user_reg_deny(u_id)
+
+
+def register(dp: Dispatcher):
+    dp.register_callback_query_handler(deny_user, text_startswith='u_deny:')

handlers/admin/manage_events.py

@@ -1,120 +0,0 @@
-from aiogram import types, Dispatcher
-from bot import database
-from bot.functions import parse_events, beauty_event_request
-from bot.keyboards import register_kb,manage_kb
-from bot import sql
-from bot.dispatcher import bot
-
-async def list_events(message: types.Message):
-    db = database.Database()
-    if not db.sql_fetchone(sql=f"select tg_id from user_table where tg_id ={message.from_user.id}") or \
-            not db.sql_fetchone(sql=f"select approved from user_table where tg_id={message.from_user.id}"):
-        await message.delete()
-        await message.answer("Команды станут доступны после регистрации", reply_markup=register_kb)
-    events = db.sql_fetchall(sql.sql_manage_events())
-    if len(events) == 0:
-        await message.answer("Заявки отсутствуют")
-    else:
-        await message.answer((beauty_event_request(parse_events(events)[0])), reply_markup=manage_kb(f"e_accept:{events[0]['id']}", f"e_deny:{events[0]['id']}", f"e_next:0",
-                                                    f"e_prev:0", f"1/{len(events)}"))
-
-
-async def next_event_page(call: types.CallbackQuery):
-    db = database.Database()
-    events = db.sql_fetchall(sql.sql_manage_events())
-    index = int(call.data.split(":")[1]) + 1
-
-    if not events:
-        await call.message.answer('Заявки отсутствуют')
-    if index == len(events):
-        pass
-    else:
-        event_id = events[index]['id']
-        await call.message.edit_text(beauty_event_request(parse_events(events)[index]),
-                                     reply_markup=manage_kb(f"e_accept:{event_id}", f"e_deny:{event_id}", f"e_next:{index}",
-                                                            f"e_prev:{index}", f"{index + 1}/{len(events)}"))
-
-
-async def prev_event_page(call: types.CallbackQuery):
-    db = database.Database()
-
-    events = db.sql_fetchall(sql.sql_manage_events())
-    index = int(call.data.split(":")[1]) - 1
-    if not events:
-        await call.message.answer('Заявки отсутствуют')
-    if index < 0:
-        pass
-    else:
-        event_id = events[index]['id']
-        await call.message.edit_text(beauty_event_request(parse_events(events)[index]),
-                                     reply_markup=manage_kb(f"e_accept:{event_id}", f"e_deny:{event_id}", f"e_next:{index}",
-                                                            f"e_prev:{index}", f"{index + 1 }/{len(events)}"))
-
-
-async def accept_event(call: types.CallbackQuery):
-    db = database.Database()
-    events = db.sql_fetchall(sql.sql_manage_events())
-    index = int(call.message.reply_markup.inline_keyboard[1][1].text.split("/")[0])-1
-    await bot.send_message(events[index]['tg_id'], "Заявка на мероприятие одобрена")
-    if len(events) == 1:
-        event_id = events[index]['id']
-        db.sql_query_send(f"UPDATE booking.events_table SET approved='1' WHERE id={event_id}")
-        await call.message.delete()
-        await call.message.answer('Заявки отсутствуют')
-    elif index == 0:
-        event_id = events[index]['id']
-        db.sql_query_send(f"UPDATE booking.events_table SET approved='1' WHERE id={event_id}")
-        await call.message.edit_text(beauty_event_request(parse_events(events)[index+1]),
-                                     reply_markup=manage_kb(f"e_accept:{event_id}", f"e_deny:{event_id}", f"e_next:{index + 1}",
-                                                            f"e_prev:{index + 1}", f"{index + 1}/{len(events) - 1}"))
-    elif index == len(events)-1:
-        event_id = events[index]['id']
-        db.sql_query_send(f"UPDATE booking.events_table SET approved='1' WHERE id={event_id}")
-        await call.message.edit_text(beauty_event_request(parse_events(events)[index-1]),
-                                     reply_markup=manage_kb(f"e_accept:{event_id}", f"e_deny:{event_id}", f"e_next:{index - 1}",
-                                                            f"e_prev:{index - 1}", f"{index}/{len(events) - 1}"))
-    else:
-        event_id = events[index]['id']
-        db.sql_query_send(f"UPDATE booking.events_table SET approved='1' WHERE id={event_id}")
-        await call.message.edit_text(beauty_event_request(parse_events(events)[index+1]),
-                                     reply_markup=manage_kb(f"e_accept:{event_id}", f"e_deny:{event_id}", f"e_next:{index}",
-                                                            f"e_prev:{index}", f"{index}/{len(events) - 1}"))
-
-
-async def deny_event(call: types.CallbackQuery):
-    db = database.Database()
-    events = db.sql_fetchall(sql.sql_manage_events())
-    index = int(call.message.reply_markup.inline_keyboard[1][1].text.split("/")[0])-1
-
-    if len(events) == 1:
-        event_id = events[index]['id']
-        db.sql_query_send(f"DELETE FROM booking.events_table WHERE id={event_id}")
-        await call.message.delete()
-        await call.message.answer('Заявки отсутствуют')
-    elif index == 0:
-        event_id = events[index]['id']
-        db.sql_query_send(f"DELETE FROM booking.events_table WHERE id={event_id}")
-        await call.message.edit_text(beauty_event_request(parse_events(events)[index+1]),
-                                     reply_markup=manage_kb(f"e_accept:{event_id}", f"e_deny:{event_id}", f"e_next:{index + 1}",
-                                                            f"e_prev:{index + 1}", f"{index + 1}/{len(events) - 1}"))
-    elif index == len(events)-1:
-        event_id = events[index]['id']
-        db.sql_query_send(f"DELETE FROM booking.events_table WHERE id={event_id}")
-        await call.message.edit_text(beauty_event_request(parse_events(events)[index-1]),
-                                     reply_markup=manage_kb(f"e_accept:{event_id}", f"e_deny:{event_id}", f"e_next:{index - 1}",
-                                                            f"e_prev:{index - 1}", f"{index}/{len(events) - 1}"))
-    else:
-        event_id = events[index]['id']
-        db.sql_query_send(f"DELETE FROM booking.events_table WHERE id={event_id}")
-        await call.message.edit_text(beauty_event_request(parse_events(events)[index+1]),
-                                     reply_markup=manage_kb(f"e_accept:{event_id}", f"e_deny:{event_id}", f"e_next:{index}",
-                                                            f"e_prev:{index}", f"{index}/{len(events) - 1}"))
-
-
-def register_handlers(dp: Dispatcher):
-    dp.register_message_handler(list_events, text='🎫 Управление мероприятиями')
-    dp.register_callback_query_handler(next_event_page, text_startswith='e_next')
-    dp.register_callback_query_handler(prev_event_page, text_startswith='e_prev')
-    dp.register_callback_query_handler(accept_event, text_startswith='e_accept')
-    dp.register_callback_query_handler(deny_event,text_startswith='e_deny')
-

handlers/admin/manage_users.py

@@ -1,122 +0,0 @@
-from bot import database
-from aiogram import types, Dispatcher
-from bot.functions import beauty_reg_request
-from bot.keyboards import manage_kb, register_kb
-from bot.dispatcher import bot
-
-
-async def list_users(message: types.Message):
-    db = database.Database()
-    if not db.sql_fetchone(sql=f"select tg_id from user_table where tg_id ={message.from_user.id}") or \
-            not db.sql_fetchone(sql=f"select approved from user_table where tg_id={message.from_user.id}"):
-        await message.delete()
-        await message.answer("Команды станут доступны после регистрации", reply_markup=register_kb)
-    if not db.sql_parse_users("select id,name,tg_id,phone from user_table where approved = '0'"):
-        await message.answer('Заявки на регистрацию отсутствуют')
-    else:
-        data = db.sql_parse_users("select id,name,tg_id,phone from user_table where approved = '0'")
-        await message.answer(beauty_reg_request(data[0]),
-                             reply_markup=manage_kb(f"u_accept:{data[0]['ID']}", f"u_deny:{data[0]['ID']}", f"u_next:0",
-                                                    f"u_prev:0", f"1/{len(data)}"))
-
-
-async def next_user_page(call: types.CallbackQuery):
-    db = database.Database()
-    data = db.sql_parse_users("select id,name,phone from user_table where approved = '0'")
-    index = int(call.data.split(":")[1]) + 1
-
-    if not data:
-        await call.message.answer('Заявки на регистрацию отсутствуют')
-    if index == len(data):
-        pass
-    else:
-        user_id = data[index]['ID']
-        await call.message.edit_text(beauty_reg_request(data[index]),
-                                     reply_markup=manage_kb(f"u_accept:{user_id}", f"u_deny:{user_id}", f"u_next:{index}",
-                                                            f"u_prev:{index}", f"{index + 1}/{len(data)}"))
-
-
-async def prev_user_page(call: types.CallbackQuery):
-    db = database.Database()
-    data = db.sql_parse_users("select id,name,phone from user_table where approved = '0'")
-    index = int(call.data.split(":")[1])-1
-    if not data:
-        await call.message.answer('Заявки на регистрацию отсутствуют')
-    elif index < 0:
-        pass
-    else:
-        user_id = data[index]['ID']
-        await call.message.edit_text(beauty_reg_request(data[index]),
-                                     reply_markup=manage_kb(f"u_accept:{user_id}", f"u_deny:{user_id}", f"u_next:{index}",
-                                                            f"u_prev:{index}", f"{index + 1}/{len(data)}"))
-
-
-async def accept_user(call: types.CallbackQuery):
-    db = database.Database()
-    data = db.sql_parse_users("select id,name,phone,tg_id from user_table where approved = '0'")
-    index = int(call.message.reply_markup.inline_keyboard[1][1].text.split("/")[0])-1
-
-    if len(data) == 1:
-        user_id = data[index]['ID']
-        db.sql_query_send(f"UPDATE booking.user_table SET approved='1' WHERE id={user_id}")
-        await call.message.delete()
-        await call.message.answer('Заявки на регистрацию отсутствуют')
-        await bot.send_message(data[index]["tg_id"], "Заявка на регистрацию одобрена")
-    elif index == 0:
-        user_id = data[index]['ID']
-        db.sql_query_send(f"UPDATE booking.user_table SET approved='1' WHERE id={user_id}")
-        await call.message.edit_text(beauty_reg_request(data[index+1]),
-                                     reply_markup=manage_kb(f"u_accept:{user_id}", f"u_deny:{user_id}", f"u_next:{index + 1}",
-                                                            f"u_prev:{index + 1}", f"{index + 1}/{len(data) - 1}"))
-
-    elif index == len(data)-1:
-        user_id = data[index]['ID']
-        db.sql_query_send(f"UPDATE booking.user_table SET approved='1' WHERE id={user_id}")
-        await call.message.edit_text(beauty_reg_request(data[index-1]),
-                                     reply_markup=manage_kb(f"u_accept:{user_id}", f"u_deny:{user_id}", f"u_next:{index - 1}",
-                                                            f"u_prev:{index - 1}", f"{index}/{len(data) - 1}"))
-    else:
-        user_id = data[index]['ID']
-        db.sql_query_send(f"UPDATE booking.user_table SET approved='1' WHERE id={user_id}")
-        await call.message.edit_text(beauty_reg_request(data[index-1]),
-                                     reply_markup=manage_kb(f"u_accept:{user_id}", f"u_deny:{user_id}", f"u_next:{index}",
-                                                            f"u_prev:{index}", f"{index}/{len(data) - 1}"))
-
-
-async def deny_user(call: types.CallbackQuery):
-    db = database.Database()
-    data = db.sql_parse_users("select id,name,phone from user_table where approved = '0'")
-    index = int(call.message.reply_markup.inline_keyboard[1][1].text.split("/")[0])-1
-
-    if len(data) == 1:
-        user_id = data[index]['ID']
-        db.sql_query_send(f"DELETE FROM booking.user_table WHERE id={user_id}")
-        await call.message.delete()
-        await call.message.answer('Заявки на регистрацию отсутствуют')
-    elif index == 0:
-        user_id = data[index]['ID']
-        db.sql_query_send(f"DELETE FROM booking.user_table WHERE id={user_id}")
-        await call.message.edit_text(beauty_reg_request(data[index+1]),
-                                     reply_markup=manage_kb(f"u_accept:{user_id}", f"u_deny:{user_id}", f"u_next:{index + 1}",
-                                                            f"u_prev:{index + 1}", f"{index + 1}/{len(data) - 1}"))
-    elif index == len(data)-1:
-        user_id = data[index]['ID']
-        db.sql_query_send(f"DELETE FROM booking.user_table WHERE id={user_id}")
-        await call.message.edit_text(beauty_reg_request(data[index-1]),
-                                     reply_markup=manage_kb(f"u_accept:{user_id}", f"u_deny:{user_id}", f"u_next:{index - 1}",
-                                                            f"u_prev:{index - 1}", f"{index}/{len(data) - 1}"))
-    else:
-        user_id = data[index]['ID']
-        db.sql_query_send(f"DELETE FROM booking.user_table WHERE id={user_id}")
-        await call.message.edit_text(beauty_reg_request(data[index-1]),
-                                     reply_markup=manage_kb(f"u_accept:{user_id}", f"u_deny:{user_id}", f"u_next:{index}",
-                                                            f"u_prev:{index}", f"{index}/{len(data) - 1}"))
-
-
-# Регистрация команд
-def admin_handlers(dp: Dispatcher):
-    dp.register_message_handler(list_users, text='👤 Управление пользователями')
-    dp.register_callback_query_handler(next_user_page, text_startswith='u_next')
-    dp.register_callback_query_handler(prev_user_page, text_startswith='u_prev')
-    dp.register_callback_query_handler(accept_user, text_startswith='u_accept')
-    dp.register_callback_query_handler(deny_user, text_startswith='u_deny')

handlers/admin/notifications.py

@@ -1,22 +0,0 @@
-# TODO: Рассылка для администраторов
-from bot.dispatcher import bot
-import bot.config as cnf
-
-
-async def new_event():
-    await bot.send_message(cnf.CHAT_ID, "Новая заявка мероприятия")
-
-
-async def new_user():
-    await bot.send_message(cnf.CHAT_ID, "Новая заявка на регистрацию")
-
-
-async def new_bug(data):
-    msg = f"<b>Обратная связь</b>\n" \
-          f"Сообщение: {data['bug']}\n" \
-          f"Отправитель: {data['from_user']}\n"
-    await bot.send_message(cnf.CHAT_ID, msg)
-
-
-async def message_to_all(msg):
-    await bot.send_message(msg)

handlers/start.py

@@ -1,37 +1,45 @@
 import asyncio
 from aiogram import types, Dispatcher
-from bot.keyboards import main_kb, register_kb,   check_register_kb
+from bot.keyboards import main_kb, register_kb
 from bot import database
 from bot import sql
 from aiogram.dispatcher.storage import FSMContext
-from handlers.user.states import SendBugState, MessageToAll
-from handlers.admin.notifications import new_bug, message_to_all
+from bot.states import SendBugState, MessageToAll
+from bot.notifications import new_bug
 
 
 # @dp.message_handler(commands=['start'])
 async def start_cmd(message: types.Message):
     db = database.Database()
-    await message.delete()
-    if not db.sql_fetchone(sql.check_id(message.from_user.id)):
-        await message.answer(f"🤖Вас приветствует лакей ТТИТ🤖\n\n"
-                             "Для доступа к функциям нужно пройти простую регистрацию\n", reply_markup=register_kb)
-    elif db.sql_fetchone(sql.check_approved(message.from_user.id)) == "0":
-        await message.answer(f"Ваша заявка находится на рассмотрении", reply_markup=check_register_kb)
-    else:
-        await message.answer(f"🤖Вас приветствует лакей ТТИТ🤖\n"
-                                   f"\n"
-                                   f"Я помогу Вам запланировать мероприятие в 405 аудитории.\n\n"
-                                   f"Меня еще разрабатыают по этому умею немного.\n\n"
-                                   f"Вот мои функции:\n"
-                                   f"Запланировать мероприятие\n"
-                                   f"Мои события\n"
-                                   f"Все события\n\n"
+    if message.chat.type == 'private':
+        if not db.sql_fetchone(sql.check_id(message.from_user.id)):
+            await message.answer(f"🤖Вас приветствует бот 405 кабинета🤖\n"
+                                 f"\n"
+                                 f"Для доступа к функционалу необходимо зарегистрироваться\n"
+                                 f"", reply_markup=register_kb())
+        elif db.sql_fetchone(f'select approved from user_table where tg_id ={message.from_user.id}') == '0':
+            msg = await message.answer("Аккаунт еще не подтвержден")
+            await asyncio.sleep(5)
+            await msg.delete()
+        else:
+
+            await message.answer(f"🤖Вас приветствует бот 405 кабинета🤖\n"
+                                   f"Я помогу Вам запланировать мероприятие.\n\n"
+                                   f"Вот что можно сделать:\n"
+                                   f"<b>Запланировать мероприятие</b>\n"
+                                   f"Планирование мероприятия\n\n"
+                                   f"<b>Мои события</b>\n"
+                                   f"События запланированные Вами\n\n"
+                                   f"<b>Все события</b>\n"
+                                   f"События всех пользователей\n"
+                                   f"с выборкой по интервалам\n\n"
                                    f"Если есть пожелания или замечания\n"
                                    f"Можете обратиться к @FeldwebelWillman\n"
                                    f"Или воспользовтаься обратной связью /feedback",
-                                   reply_markup=main_kb)
-        # await asyncio.sleep(10)
-        # await msg.delete()
+                                   reply_markup=main_kb())
+    # else:
+    #     await message.answer(f"Если Вы хотите , запланировать мероприятие в 405"
+    #                          f"напишите лично @TTITTechSuppBot")
 
 
 async def stop_cmd(message: types.Message):
@@ -45,7 +53,7 @@ async def send_report(message: types.Message):
     await message.delete()
     await SendBugState.send_bug.set()
     msg = await message.answer("Опишите проблему")
-    await asyncio.sleep(5)
+    await asyncio.sleep(60)
     await msg.delete()
 
 
@@ -75,11 +83,6 @@ async def get_message(message: types.Message, state: FSMContext):
     await message.delete()
 
 
-async def delete_all_msg(message: types.Message):
-    await asyncio.sleep(5)
-    await message.delete()
-
-
 def main_register(dp: Dispatcher):
     dp.register_message_handler(start_cmd, commands=['start', 'help'])
     dp.register_message_handler(stop_cmd, commands=['stop'])
@@ -87,5 +90,4 @@ def main_register(dp: Dispatcher):
     dp.register_message_handler(get_report, state=SendBugState.send_bug)
     dp.register_message_handler(broadcast_cmd, commands=['broadcast'])
     dp.register_message_handler(get_message, state=MessageToAll.send_message)
-    dp.register_message_handler(delete_all_msg)
 

handlers/user/__init__.py

@@ -1,4 +1,4 @@
 import handlers.user.registration
-import handlers.user.make_events
-import handlers.user.states
-import handlers.user.show_events
+import handlers.user.make_event
+import handlers.user.my_events
+import handlers.user.all_events

handlers/user/all_events.py

@@ -0,0 +1,44 @@
+from aiogram import types, Dispatcher
+from bot import database, sql
+from bot.functions import beauty_all_events, date_range
+from bot.keyboards import events_range_kb
+
+
+async def all_events(call: types.CallbackQuery):
+    await call.message.edit_text("Выберете интересующий диапазон", reply_markup=events_range_kb())
+
+
+async def select_range(call: types.CallbackQuery):
+    if call.data == "today":
+        db = database.Database()
+        time = "'" + str(date_range("today")) + "'"
+        data = db.sql_fetchall(sql=sql.get_all_events(time))
+        if len(data) == 0:
+            await call.message.answer("Сегодня мероприятий нет")
+        else:
+            await call.message.answer(beauty_all_events(sorted(data, key=lambda d: d['e_date'])))
+
+    if call.data == "week":
+        db = database.Database()
+        time = date_range("week").split(" ")
+        time = "'" + time[0] + "' " + time[1] + " '" + time[2] + "'"
+        data = db.sql_fetchall(sql=sql.get_range_events(time))
+        if len(data) == 0:
+            await call.message.answer("На этой неделе мероприятий нет")
+        else:
+            await call.message.answer(beauty_all_events(sorted(data, key=lambda d: d['e_date'])))
+
+    if call.data == "month":
+        db = database.Database()
+        time = date_range("month").split(" ")
+        time = "'" + time[0] + "' " + time[1] + " '" + time[2] + "'"
+        data = db.sql_fetchall(sql=sql.get_range_events(time))
+        if len(data) == 0:
+            await call.message.answer("В этом месяце мероприятий нет")
+        else:
+            await call.message.answer(beauty_all_events(sorted(data, key=lambda d: d['e_date'])))
+
+
+def register(dp: Dispatcher):
+    dp.register_callback_query_handler(all_events, text='all_events')
+    dp.register_callback_query_handler(select_range, text=(['month', 'week', 'today']))

handlers/user/make_events.py

@@ -1,36 +1,37 @@
 import asyncio
+import calendar
+from datetime import date, datetime
+
 from aiogram import types, Dispatcher
+from aiogram.dispatcher.storage import FSMContext
+
 from bot import database, sql
-from bot.keyboards import register_kb, make_calendar, events_kb, cancel_booking, main_kb
 from bot.functions import make_date, time_validator, normalize_time, to_quotes, check_overlap, beauty_booked_time
-from handlers.user.states import BookingState
-from aiogram.dispatcher.storage import FSMContext
-from bot import messages
-from handlers.admin.notifications import new_event
-from datetime import date, datetime
-import calendar
+from bot.keyboards import make_calendar, events_kb, cancel_booking, main_kb
+from bot.notifications import new_event
+from bot.states import BookingState
+
 
+async def make_event(call: types.CallbackQuery):
 
-async def make_event(message: types.message):
     today = date.today()
     month = today.month
     days_in_month = calendar.monthrange(today.year, month)[1]
     db = database.Database()
-    if not db.sql_fetchone(f"select tg_id from user_table where tg_id ={message.from_user.id}") or \
-            not db.sql_fetchone(f"select approved from user_table where tg_id={message.from_user.id}"):
-        await message.delete()
-        await message.answer(messages.non_register, reply_markup=register_kb)
-    else:
-        if message.text == "🎯 Запланировать мероприятие":
-            await message.delete()
-            await message.answer(messages.events_welcome(make_date()), reply_markup=make_calendar(month,
-                                                                                                  days_in_month,
-                                                                                                  f"month_prev:{month}",
-                                                                                                  f"month_next:{month}"))
+    text = (f"выберите дату чтобы увидеть список мероприятий\n\n"
+            f"Так же календарь мероприятий можно посмотреть в "
+            f"<a href=moodle.tomtit-tomsk.ru>Moodle</a>\n\n"
+            f"Сегодняшняя дата <b>{make_date()}</b>")
+    await call.message.edit_text(text, reply_markup=make_calendar(month,
+                                                                  days_in_month,
+                                                                  f"month_prev:{month}",
+                                                                  f"month_next:{month}"))
 
 
 async def select_date(call: types.CallbackQuery, state: FSMContext):
     db = database.Database()
+    username = db.sql_fetchone(f"select name from user_table where tg_id = {call.from_user.id}")
+    await state.update_data(username=username)
     date = call.data.split("_")[1]
     booked = db.sql_fetchall(sql.sql_booked_time(date))
     today = datetime.strftime(datetime.today(), '%Y-%m-%d')
@@ -79,22 +80,25 @@ async def select_date(call: types.CallbackQuery, state: FSMContext):
 
 
 async def edit_date(call: types.CallbackQuery, state: FSMContext):
-    today = date.today()
-    month = today.month
-    days_in_month = calendar.monthrange(today.year, month)[1]
-    await call.message.edit_text(f"выберите дату чтобы увидеть список мероприятий\n\n"
-                                 f"Так же календарь мероприятий можно посмотреть в "
-                                 f"<a href=moodle.tomtit-tomsk.ru>Moodle</a>\n\n"
-                                 f"Сегодняшняя дата <b>{make_date()}</b>", reply_markup=make_calendar(month,
-                                                                                                      days_in_month,
-                                                                                                      f"month_prev:{month}",
-                                                                                                      f"month_next:{month}"))
-
+    await call.message.edit_text(f"🤖Вас приветствует бот 405 кабинета🤖\n"
+                                 f"Я помогу Вам запланировать мероприятие.\n\n"
+                                 f"Вот что можно сделать:\n"
+                                 f"<b>Запланировать мероприятие</b>\n"
+                                 f"Планирование мероприятия\n\n"
+                                 f"<b>Мои события</b>\n"
+                                 f"События запланированные Вами\n\n"
+                                 f"<b>Все события</b>\n"
+                                 f"События всех пользователей\n"
+                                 f"с выборкой по интервалам\n\n"
+                                 f"Если есть пожелания или замечания\n"
+                                 f"Можете обратиться к @FeldwebelWillman\n"
+                                 f"Или воспользовтаься обратной связью /feedback",
+                                 reply_markup=main_kb())
     await state.finish()
 
 
 async def booking_date(call: types.CallbackQuery):
-    await call.message.answer("Введите диапазон времени\n"
+    await call.message.edit_text("Введите диапазон времени\n"
                               "Возможные форматы\n\n"
                               "13.00 15.30\n"
                               "8.00-9.00\n"
@@ -132,44 +136,31 @@ async def send_event(message: types.Message, state: FSMContext):
         await message.answer("Описание слишком длинное")
 
     else:
+
         await state.update_data(description=message.text)
         await state.update_data(approved=0)
         data = await state.get_data()
+        db.sql_query_send(sql.sql_send_event(data))
         await message.delete()
         await message.answer("Заявка принята\n"
                              "Уведомлять администраторов не требуется\n"
-                             "они получат оповощение автоматически", reply_markup=main_kb)
+                             "они получат оповощение автоматически\n"
+                             "Для новой заявки используйте /start")
+        event_id = db.sql_fetchone('select max(id) from events_table')
+        await state.update_data(id=event_id)
+        data = await state.get_data()
         await state.finish()
-        db.sql_query_send(sql.sql_send_event(data))
-        await new_event()
-
+        await new_event(data)
 
-async def next_month(call: types.CallbackQuery):
-    m_id = int(call.data.split(":")[1])+1
-    days = calendar.monthrange(2022, m_id)[1]
-    await call.message.edit_reply_markup(reply_markup=make_calendar(m_id,
-                                                                    days,
-                                                                    f"month_prev:{m_id}",
-                                                                    f"month_next:{m_id}"))
 
-
-async def prev_month(call: types.CallbackQuery):
-    m_id = int(call.data.split(":")[1])-1
-    days = calendar.monthrange(2022, m_id)[1]
-    await call.message.edit_reply_markup(reply_markup=make_calendar(m_id,
-                                                                    days,
-                                                                    f"month_prev:{m_id}",
-                                                                    f"month_next:{m_id}"))
-
-
-def events_register(dp: Dispatcher):
-    dp.register_message_handler(make_event, text="🎯 Запланировать мероприятие")
+def register(dp: Dispatcher):
+    dp.register_callback_query_handler(make_event, text='plain')
     dp.register_callback_query_handler(select_date, text_startswith='date_')
+    dp.register_callback_query_handler(edit_date, text='cancel_booking')
+    dp.register_callback_query_handler(booking_date, text='booking', state=BookingState.start)
     dp.register_callback_query_handler(edit_date, text=['change', 'cancel_booking'], state=[BookingState.start,
                                                                                             BookingState.time,
                                                                                             BookingState.description])
-    dp.register_callback_query_handler(booking_date, text='booking', state=BookingState.start)
+
     dp.register_message_handler(get_time, state=BookingState.time)
-    dp.register_message_handler(send_event, state=BookingState.description)
-    dp.register_callback_query_handler(next_month, text_startswith='month_next')
-    dp.register_callback_query_handler(prev_month, text_startswith='month_prev')
+    dp.register_message_handler(send_event, state=BookingState.description)

handlers/user/my_events.py

@@ -0,0 +1,16 @@
+from aiogram import types, Dispatcher
+from bot import database, sql
+from bot.functions import beauty_all_events
+
+
+async def my_events(call: types.CallbackQuery):
+    db = database.Database()
+    data = db.sql_fetchall(sql=sql.get_user_event(call.from_user.id))
+    if len(data) == 0:
+        await call.message.answer("Вы не планировали мероприятия")
+    else:
+        await call.message.answer(beauty_all_events(sorted(data, key=lambda d: d['e_date'])))
+
+
+def register(dp: Dispatcher):
+    dp.register_callback_query_handler(my_events, text='my_events')

handlers/user/registration.py

@@ -1,87 +1,88 @@
+import asyncio
 from aiogram import types, Dispatcher
-from handlers.user.states import RegisterStates
-from bot.functions import validate_fio, validate_phone, reject_latin, reject_cmd
 from aiogram.dispatcher.storage import FSMContext
-from bot.keyboards import reset_register_kb, register_kb, main_kb, check_register_kb
-from bot import database, sql
-from handlers.admin.notifications import new_user
+from bot import database
+from bot.states import RegisterStates
+from bot.keyboards import reset_register_kb, register_kb
+from bot.functions import validate_phone, reject_latin, reject_cmd, validate_fio
+from bot.notifications import new_user
 
 
-async def registration(message: types.Message):
-    db = database.Database()
-    await message.delete()
-    if db.sql_fetchone(f'select tg_id from user_table where tg_id = {message.from_user.id} and approved = 0'):
-        await message.answer("Ваша заявка находится на рассмотрернии", reply_markup=check_register_kb)
-    elif db.sql_fetchone(f'select tg_id from user_table where tg_id = {message.from_user.id} and approved = 1'):
-        msg = await message.answer("Вы зарегистрированы", reply_markup=main_kb)
-        await msg.delete()
-    else:
-        await message.answer(f"Для регистрации необходимо указать номер телефона")
-
-        await message.answer(f"Введите номер телефона\n"
-                             f"Возможные форматы:\n\n"
-                             f"<b>+79995554433</b>\n"
-                             f"<b>9997771122</b>\n"
-                             f"<b>89995554433</b>\n"
-                             f"<b>8-999-888-11-22</b>\n"
-                             f"<b>+7-999-888-11-22</b>", reply_markup=reset_register_kb)
-        await RegisterStates.phone.set()
-
-
-async def check_reg_status(message: types.Message):
-    db = database.Database()
-    await message.delete()
-    if db.sql_fetchone(f'select tg_id from user_table where tg_id = {message.from_user.id} and approved = 0'):
-        await message.answer("Ваша заявка находится на рассмотрернии", reply_markup=check_register_kb)
-    elif db.sql_fetchone(f'select tg_id from user_table where tg_id = {message.from_user.id} and approved = 1'):
-        await message.answer("Вы зарегистрированы", reply_markup=main_kb)
-    else:
-        await message.answer("Вы не зарегистрированы", reply_markup=register_kb)
+async def registration(call: types.CallbackQuery):
+    await call.message.edit_text(f"Введите номер телефона\n"
+                                 f"Возможные форматы:\n\n"
+                                 f"<b>+79995554433</b>\n"
+                                 f"<b>9997771122</b>\n"
+                                 f"<b>89995554433</b>\n"
+                                 f"<b>8-999-888-11-22</b>\n"
+                                 f"<b>+7-999-888-11-22</b>", reply_markup=reset_register_kb())
+    await RegisterStates.phone.set()
 
 
 async def get_number(message: types.Message, state: FSMContext):
     if validate_phone(message.text):
         await state.update_data(number=message.text)
-        await message.answer(f"Укажите ФИО\n"
-                             f"Например: Иванов Иван Иванович", reply_markup=reset_register_kb)
+        await message.delete()
+        msg = await message.answer(f"Укажите ФИО\n"
+                                   f"Например: Иванов Иван Иванович")
+
         await RegisterStates.FIO.set()
+        await asyncio.sleep(60)
+        await msg.delete()
     else:
         await message.delete()
-        await message.answer(f"Указан некорректный номер телефона", reply_markup=reset_register_kb)
+        msg = await message.answer(f"Указан некорректный номер телефона")
+        await asyncio.sleep(5)
+        await msg.delete()
 
 
 async def get_fio(message: types.Message, state: FSMContext):
     db = database.Database()
     if reject_cmd(message.text):
         await message.delete()
-        await message.answer("Нельзя использовать команды", reply_markup=reset_register_kb)
+        msg = await message.answer("Нельзя использовать команды")
+        await asyncio.sleep(5)
+        await msg.delete()
     elif reject_latin(message.text):
         await message.delete()
-        await message.answer("Нельзя использовать латиницу и символы", reply_markup=reset_register_kb)
+        msg = await message.answer("Нельзя использовать латиницу и символы")
+        await asyncio.sleep(5)
+        await msg.delete()
     elif validate_fio(message.text):
-        await message.answer("Необходимо указать полное ФИО", reply_markup=reset_register_kb)
+        await message.delete()
+        msg = await message.answer("Необходимо указать полное ФИО")
+        await asyncio.sleep(5)
+        await msg.delete()
     else:
+        await message.delete()
+
         await state.update_data(FIO=message.text)
         await state.update_data(id=message.from_user.id)
+        await state.update_data(tg=message.from_user.username)
         reg_data = await state.get_data()
-        await message.answer(f"Спасибо за регистрацию\n"
-                             f"Вы сможете воспользоваться функциями после одобрения\n", reply_markup=check_register_kb)
-
-        db.sql_query_send(sql.sql_send(reg_data))
         await state.finish()
-        await new_user()
+        msg = await message.answer(f"Заявка отправлена")
+        db.sql_query_send(f"INSERT INTO user_table (tg_id,name,phone)"
+                          f"VALUES ({reg_data['id']},"
+                          f"'{reg_data['FIO']}',"
+                          f"'{reg_data['number']}')")
+        await new_user(reg_data)
+        await asyncio.sleep(5)
+        await msg.delete()
 
 
-async def reset_register(message: types.Message, state: FSMContext):
+async def reset_register(call: types.CallbackQuery, state: FSMContext):
     await state.finish()
-    await message.answer("Регистрация отменена", reply_markup=register_kb)
+    await call.message.edit_text(f"🤖Вас приветствует бот 405 кабинета🤖\n"
+                                 f"\n"
+                                 f"Для доступа к функционалу необходимо зарегистрироваться\n"
+                                 f"", reply_markup=register_kb())
 
 
-def register_handlers(dp: Dispatcher):
-    # хендлеры регистрации
-    dp.register_message_handler(registration, text="Зарегистрироваться")
-    dp.register_message_handler(check_reg_status, text="Проверить статус заявки")
-    dp.register_message_handler(reset_register, text='Отменить регистрацию', state=[RegisterStates.phone,
-                                                                                    RegisterStates.FIO])
+def register(dp: Dispatcher):
+    dp.register_callback_query_handler(registration, text="register")
+    dp.register_callback_query_handler(reset_register, text="res_register", state=[RegisterStates.phone,
+                                                                                   RegisterStates.FIO])
     dp.register_message_handler(get_number, state=RegisterStates.phone)
     dp.register_message_handler(get_fio, state=RegisterStates.FIO)
+

handlers/user/show_events.py

@@ -1,71 +0,0 @@
-from bot import database
-from aiogram import types, Dispatcher
-from bot.keyboards import register_kb, events_range_kb
-from bot.functions import date_range, beauty_all_events
-from bot import sql
-
-
-async def my_events(message: types.Message):
-    await message.delete()
-    db = database.Database()
-    if db.sql_fetchone(sql=sql.check_approved(message.from_user.id)) == "0" or db.sql_fetchone(
-            sql=sql.check_id(message.from_user.id)) == "0":
-        await message.delete()
-        await message.answer("Команды станут доступны после регистрации", reply_markup=register_kb)
-    else:
-        data = db.sql_fetchall(sql=sql.get_user_event(message.from_user.id))
-        if len(data) == 0:
-            await message.answer("Вы не планировали мероприятия")
-        else:
-            await message.answer(beauty_all_events(sorted(data, key=lambda d: d['e_date'])))
-
-
-async def all_events(message: types.Message):
-    await message.delete()
-    db = database.Database()
-    if db.sql_fetchone(sql=sql.check_approved(message.from_user.id)) == "0" or db.sql_fetchone(
-            sql=sql.check_id(message.from_user.id)) == "0":
-        await message.delete()
-        await message.answer("Команды станут доступны после регистрации", reply_markup=register_kb)
-    else:
-        await message.answer("Выберете интересующий диапазон", reply_markup=events_range_kb())
-
-
-# TODO: Визуальное оформление событий
-
-
-async def select_range(call: types.CallbackQuery):
-    if call.data == "today":
-        db = database.Database()
-        time = "'" + str(date_range("today")) + "'"
-        data = db.sql_fetchall(sql=sql.get_all_events(time))
-        if len(data) == 0:
-            await call.message.answer("Сегодня мероприятий нет")
-        else:
-            await call.message.answer(beauty_all_events(sorted(data, key=lambda d: d['e_date'])))
-
-    if call.data == "week":
-        db = database.Database()
-        time = date_range("week").split(" ")
-        time = "'" + time[0] + "' " + time[1] + " '" + time[2] + "'"
-        data = db.sql_fetchall(sql=sql.get_range_events(time))
-        if len(data) == 0:
-            await call.message.answer("На этой неделе мероприятий нет")
-        else:
-            await call.message.answer(beauty_all_events(sorted(data, key=lambda d: d['e_date'])))
-
-    if call.data == "month":
-        db = database.Database()
-        time = date_range("month").split(" ")
-        time = "'" + time[0] + "' " + time[1] + " '" + time[2] + "'"
-        data = db.sql_fetchall(sql=sql.get_range_events(time))
-        if len(data) == 0:
-            await call.message.answer("В этом месяце мероприятий нет")
-        else:
-            await call.message.answer(beauty_all_events(sorted(data, key=lambda d: d['e_date'])))
-
-
-def register(dp: Dispatcher):
-    dp.register_message_handler(my_events, text="🗒 Мои события")
-    dp.register_message_handler(all_events, text="📅 Все события")
-    dp.register_callback_query_handler(select_range, text=(['month', 'week', 'today']))

main.py

@@ -1,17 +1,20 @@
 from aiogram.utils import executor
 from bot.dispatcher import dp
-import handlers.admin.admin_menu
 import logging
+import handlers
 from Moodle.scheduler import on_start
 
 
 if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO)
-    handlers.user.registration.register_handlers(dp)
-    handlers.user.make_events.events_register(dp)
-    handlers.user.show_events.register(dp)
-    handlers.admin.admin_menu.register_admin_menu(dp)
-    handlers.admin.manage_users.admin_handlers(dp)
-    handlers.admin.manage_events.register_handlers(dp)
     handlers.start.main_register(dp)
+    handlers.user.registration.register(dp)
+    handlers.user.make_event.register(dp)
+
+    handlers.admin.deny_user.register(dp)
+    handlers.admin.accept_user.register(dp)
+    handlers.admin.accept_event.register(dp)
+    handlers.admin.deny_event.register(dp)
+    handlers.user.my_events.register(dp)
+    handlers.user.all_events.register(dp)
     executor.start_polling(dp, skip_updates=True)  # , on_startup=on_start