Некорректно работают функции управления пользователями и мероприятиями

bot/database.py

@@ -39,6 +39,16 @@ class Database:
             for v in response.values():
                 return v
 
+    def sql_fetchall(self, sql: str):
+        self.execute(sql)
+        result_set = self.fetchall()
+        return result_set
+
+    def sql_query_send(self, sql: str):
+        self.execute(sql)
+        self.commit()
+        self.close()
+
     def sql_parse_users(self, sql: str):
         self.execute(sql)
         result_set = self.fetchall()
@@ -63,14 +73,4 @@ class Database:
                 events_list.append(event_data)
             return events_list
 
-    def sql_fetchall(self, sql: str):
-        self.execute(sql)
-        result_set = self.fetchall()
-        return result_set
-
-    def sql_query_send(self, sql: str):
-        self.execute(sql)
-        self.commit()
-        self.close()
-
 

bot/functions.py

@@ -139,3 +139,19 @@ def check_overlap(start, end, date):
     for time in times:
         it.addi(time['e_start'], time['e_end'])
     return not it.overlaps(start, end)
+
+
+def parse_events(data):
+    events_list = []
+    for elem in data:
+        event = {"ID": elem['id'],
+                 "Инициатор": elem['name'],
+                 "Номер телефона": elem['phone'],
+                 "Описание": elem['description'],
+                 "Начало в": elem['e_start'],
+                 "Конец в": elem['e_end']}
+
+        events_list.append(event)
+    return events_list
+
+# [{'name': 'Шаймагсумов Вильдан Маратович', 'phone': '79539299323', 'description': 'asdasdasd', 'e_start': '13:00', 'e_end': '15:30'},

bot/keyboards.py

@@ -39,7 +39,7 @@ admin_keyboard.add(back)
 
 
 # Клавиатура для заявок
-def user_manage_kb(b_accept, b_deny, b_next, b_prev, b_count):
+def manage_kb(b_accept, b_deny, b_next, b_prev, b_count):
     keyboard = InlineKeyboardMarkup()
     accept_button = InlineKeyboardButton(text="Одобрить", callback_data=b_accept)
     deny_button = InlineKeyboardButton(text="Отклонить", callback_data=b_deny)

bot/messages.py

@@ -0,0 +1,22 @@
+# Для форматирования сообщений
+
+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
+
+
+

draft.py

@@ -1,3 +1,4 @@
+# Черновик
 import intervaltree
 
 it = intervaltree.IntervalTree()

handlers/admin/manage_events.py

@@ -1,8 +1,9 @@
 # TODO: Добавить управление мероприятиями
 from aiogram import types, Dispatcher
 from bot import database
-from bot.functions import beauty_reg_request
-from bot.keyboards import register_kb,user_manage_kb
+from bot.functions import parse_events
+from bot.keyboards import register_kb,manage_kb
+from bot import sql
 
 
 async def list_events(message: types.Message):
@@ -11,20 +12,85 @@ async def list_events(message: types.Message):
             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,phone from user_table where approved = '0'"):
-        await message.answer('Заявки на мероприятия остутствуют')
+    events = db.sql_fetchall(sql.sql_manage_events())
+    if len(events) == 0:
+        await message.answer("Заявки отсутствуют")
     else:
-        await message.answer("заявки есть")
-        # data = db.sql_parse_users("select id,name,phone from user_table where approved = '0'")
-        # await message.answer("test",
-        #                      reply_markup=user_manage_kb(f"accept:{data[0]['ID']}",
-        #                                                  f"deny:{data[0]['ID']}",
-        #                                                  f"next:0",
-        #                                                  f"prev:0",
-        #                                                  f"1/{len(data)}"))
+        await message.answer(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
+        print("next")
+    else:
+        event_id = events[index]['id']
+        await call.message.edit_text(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:
+        print(events)
+        print("prev")
+        pass
+    else:
+        event_id = events[index]['id']
+        await call.message.edit_text(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
+
+    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(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(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}"))
+        print("2 " +index)
+    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(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}"))
+        print(event_id, index)
 
 
 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')
 

handlers/admin/manage_users.py

@@ -1,7 +1,7 @@
 from bot import database
 from aiogram import types, Dispatcher
 from bot.functions import beauty_reg_request
-from bot.keyboards import user_manage_kb, register_kb
+from bot.keyboards import manage_kb, register_kb
 
 
 async def list_users(message: types.Message):
@@ -15,11 +15,8 @@ async def list_users(message: types.Message):
     else:
         data = db.sql_parse_users("select id,name,phone from user_table where approved = '0'")
         await message.answer(beauty_reg_request(data[0]),
-                             reply_markup=user_manage_kb(f"accept:{data[0]['ID']}",
-                                                         f"deny:{data[0]['ID']}",
-                                                         f"next:0",
-                                                         f"prev:0",
-                                                         f"1/{len(data)}"))
+                             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):
@@ -34,11 +31,8 @@ async def next_user_page(call: types.CallbackQuery):
     else:
         user_id = data[index]['ID']
         await call.message.edit_text(beauty_reg_request(data[index]),
-                                     reply_markup=user_manage_kb(f"accept:{user_id}",
-                                                                 f"deny:{user_id}",
-                                                                 f"next:{index}",
-                                                                 f"prev:{index}",
-                                                                 f"{index + 1}/{len(data)}"))
+                                     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):
@@ -52,11 +46,8 @@ async def prev_user_page(call: types.CallbackQuery):
     else:
         user_id = data[index]['ID']
         await call.message.edit_text(beauty_reg_request(data[index]),
-                                     reply_markup=user_manage_kb(f"accept:{user_id}",
-                                                                 f"deny:{user_id}",
-                                                                 f"next:{index}",
-                                                                 f"prev:{index}",
-                                                                 f"{index+1}/{len(data)}"))
+                                     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):
@@ -73,34 +64,25 @@ async def accept_user(call: types.CallbackQuery):
         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=user_manage_kb(f"accept:{user_id}",
-                                                                 f"deny:{user_id}",
-                                                                 f"next:{index + 1}",
-                                                                 f"prev:{index + 1}",
-                                                                 f"{index+1}/{len(data) - 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=user_manage_kb(f"accept:{user_id}",
-                                                                 f"deny:{user_id}",
-                                                                 f"next:{index - 1}",
-                                                                 f"prev:{index - 1}",
-                                                                 f"{index}/{len(data) - 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=user_manage_kb(f"accept:{user_id}",
-                                                                 f"deny:{user_id}",
-                                                                 f"next:{index}",
-                                                                 f"prev:{index - 1}",
-                                                                 f"{index}/{len(data) - 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='next')
-    dp.register_callback_query_handler(prev_user_page, text_startswith='prev')
-    dp.register_callback_query_handler(accept_user, text_startswith='accept')
+    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')

handlers/start.py

@@ -18,15 +18,15 @@ async def start_cmd(message: types.Message):
         await message.answer(f"Ваша заявка находится на рассмотрернии", reply_markup=check_register_kb)
     else:
         await message.answer(f"🤖Вас приветствует лакей ТТИТ🤖\n"
-                             "\n"
-                             "Я помогу Вам запланировать мероприятие в 405 аудитории.\n\n"
-                             "Меня еще разрабатыают по этому умею немного.\n\n"
-                             "Вот мои функции:\n"
-                             "Запланировать мероприятие\n"
-                             "Мои события\n"
-                             "Все события(В разработке)\n\n"
-                             "Если есть пожелания или замечания\n"
-                             "Можете обратиться к создателю @FeldwebelWillman",
+                             f"\n"
+                             f"Я помогу Вам запланировать мероприятие в 405 аудитории.\n\n"
+                             f"Меня еще разрабатыают по этому умею немного.\n\n"
+                             f"Вот мои функции:\n"
+                             f"Запланировать мероприятие\n"
+                             f"Мои события\n"
+                             f"Все события\n\n"
+                             f"Если есть пожелания или замечания\n"
+                             f"Можете обратиться к @FeldwebelWillman",
                              reply_markup=main_kb)
 
 

handlers/user/make_events.py

@@ -4,6 +4,12 @@ from bot.keyboards import register_kb, make_calendar, events_kb, cancel_booking,
 from bot.functions import make_date, time_validator, normalize_time, to_quotes, check_overlap
 from handlers.user.states import BookingState
 from aiogram.dispatcher.storage import FSMContext
+from bot import messages
+
+
+# TODO: Убрать вывод данных состояния
+# Добавить визуализацию занятого времени
+# Переписать реактирование сообщений
 
 
 async def make_event(message: types.message):
@@ -11,22 +17,18 @@ async def make_event(message: types.message):
     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("Команды станут доступны после регистрации", reply_markup=register_kb)
+        await message.answer(messages.non_register, reply_markup=register_kb)
     else:
         if message.text == "🎯 Запланировать мероприятие":
             await message.delete()
             # TODO: Добавить переход на следующий месяц
-            await message.answer(f"выберите дату чтобы увидеть список мероприятий\n\n"
-                                 f"Так же календарь мероприятий можно посмотреть в "
-                                 f"<a href=moodle.tomtit-tomsk.ru>Moodle</a>\n\n"
-                                 f"Сегодняшняя дата <b>{make_date()}</b>", reply_markup=make_calendar())
+            await message.answer(messages.events_welcome(make_date()), reply_markup=make_calendar())
 
 
 async def select_date(call: types.CallbackQuery, state: FSMContext):
     db = database.Database()
     date = call.data.split("_")[1]
-    booked = db.sql_fetchall(
-        f"select events_table.e_start, events_table.e_end from events_table WHERE e_date = {to_quotes(date)}")
+    booked = db.sql_fetchall(sql.sql_booked(date))
     await BookingState.start.set()
     await state.update_data(date=to_quotes(date))
     await state.update_data(owner=call.from_user.id)
@@ -34,7 +36,9 @@ async def select_date(call: types.CallbackQuery, state: FSMContext):
         await call.message.edit_text(f"Вы выбрали дату: {date}\n"
                                      f"На этот день мероприятий не заплпнированно", reply_markup=events_kb())
     else:
-        await call.message.edit_text(sorted(booked, key=lambda t: t['e_start'], reverse=True), reply_markup=events_kb())
+        await call.message.edit_text(f"Вы выбрали дату: {date}\n"
+                                     f"{sorted(booked, key=lambda t: t['e_start'], reverse=True)}",
+                                     reply_markup=events_kb())
 
 
 async def edit_date(call: types.CallbackQuery, state: FSMContext):
@@ -42,20 +46,21 @@ async def edit_date(call: types.CallbackQuery, state: FSMContext):
                                  f"Так же календарь мероприятий можно посмотреть в "
                                  f"<a href=moodle.tomtit-tomsk.ru>Moodle</a>\n\n"
                                  f"Сегодняшняя дата <b>{make_date()}</b>", reply_markup=make_calendar())
+    await call.message.delete()
     await state.finish()
 
 
 async def booking_date(call: types.CallbackQuery):
-    await call.message.edit_text("Введите диапазон времени\n"
-                                 "Возможные форматы\n\n"
-                                 "13.00 15.30\n"
-                                 "13.00-15.30\n"
-                                 "13:00 15:30\n"
-                                 "13.00-15.30\n", reply_markup=cancel_booking())
+    await call.message.answer("Введите диапазон времени\n"
+                              "Возможные форматы\n\n"
+                              "13.00 15.30\n"
+                              "13.00-15.30\n"
+                              "13:00 15:30\n"
+                              "13.00-15.30\n", reply_markup=cancel_booking())
     await BookingState.time.set()
 
 
-async def get_date(message: types.Message, state: FSMContext):
+async def get_time(message: types.Message, state: FSMContext):
     # Парсим то что ввел пользователь
     time = normalize_time(message.text)
     # Забираем текущую дату
@@ -73,8 +78,6 @@ async def get_date(message: types.Message, state: FSMContext):
     else:
         await message.answer("Неверный формат времени")
 
-    # TODO: огран по длине текста
-
 
 async def send_event(message: types.Message, state: FSMContext):
     db = database.Database()
@@ -86,7 +89,6 @@ async def send_event(message: types.Message, state: FSMContext):
         data = await state.get_data()
         await message.answer("Заявка принята", reply_markup=main_kb)
         await state.finish()
-        await message.answer(data)
         db.sql_query_send(sql.sql_send_event(data))
 
 
@@ -97,5 +99,5 @@ def events_register(dp: Dispatcher):
                                                                                             BookingState.time,
                                                                                             BookingState.description])
     dp.register_callback_query_handler(booking_date, text='booking', state=BookingState.start)
-    dp.register_message_handler(get_date, state=BookingState.time)
+    dp.register_message_handler(get_time, state=BookingState.time)
     dp.register_message_handler(send_event, state=BookingState.description)