demo 1.0

code/base.py

@@ -0,0 +1,4 @@
+TOKEN = "-"
+
+ID_BOT = **********
+TEX_GROUP = "-*********"

code/bot.py

@@ -0,0 +1,327 @@
+import logging, asyncio, random
+import base, pars, sql, os
+import datetime as dt
+
+from aiogram import Bot, Dispatcher, executor, types
+
+# log level
+logging.basicConfig(level=logging.INFO)
+
+# bot init
+bot = Bot(token=base.TOKEN)
+dp = Dispatcher(bot)
+
+# db init
+db = sql.Base('../db/base.db')
+du = sql.User('../db/users.db')
+dg = sql.Group('../db/groups.db')
+dn = sql.Now('../db/now.db')
+dn.check_group()
+
+
+@dp.message_handler(commands="start")
+async def start(message: types.Message):
+    if 0 > int(message.chat.id):
+        await message.answer("", types.ParseMode.MARKDOWN)
+
+
+# ОБНОВЛЕНИЕ АЙДИ ГРУППЫ
+@dp.message_handler(content_types=['migrate_to_chat_id', 'migrate_from_chat_id'])
+async def chat_reload(message: types.Message):
+    if du.group_exists(message.migrate_from_chat_id):
+        du.update_group_id(message.migrate_from_chat_id, message.migrate_to_chat_id)
+
+
+# КОМАНДЫ
+@dp.message_handler(commands="help")
+async def hlp(message: types.Message):
+    await message.answer("*Инструкция использования:*\n\n"
+                         "*/eat* - с помощью этой команды вы можете заказать питание\n"
+                         "*/today* - команда выдающая меню на сегодня\n"
+                         "*/tomorrow* - команда выдающая меню на завтра\n\n"
+                         "*/add_group* - команда выдающая меню на завтра\n"
+                         "*/del_group* - команда выдающая меню на завтра\n", types.ParseMode.MARKDOWN)
+
+
+@dp.message_handler(commands="eat")
+async def eat(message: types.Message):
+    if 0 > int(message.chat.id):
+        keyboard1 = {"inline_keyboard":
+                        [[{"text": "Завтрак", "callback_data": "z"}, {"text": "Обед", "callback_data": "o"},
+                          {"text": "Полдник", "callback_data": "p"}], [{"text": "Завтрак / Обед", "callback_data": "zo"}],
+                         [{"text": "Завтрак / Полдник", "callback_data": "zp"}],
+                         [{"text": "Обед / Полдник", "callback_data": "op"}],
+                         [{"text": "Завтрак / Обед / Полдник", "callback_data": "zop"}]]}
+
+        await bot.send_message(chat_id=message.chat.id,
+                               text='*Это меню выбора притания!* Всё, что вам надо сделать, это лишь выбрать '
+                                    'необходимый заказ.\n\nEсли после нажатия бот написал, что вы выбрали, то всё '
+                                    'прошло успешно и вы можете не беспокоиться!', parse_mode=types.ParseMode.MARKDOWN,
+                               reply_markup=keyboard1)
+
+        keyboard2 = {"inline_keyboard": [[{"text": "Отменить заказ", "callback_data": "cancel"}]]}
+        await bot.send_message(chat_id=message.chat.id,
+                               text='Если вы хотите сменить заказ, то отмените действующий заказ по кнопке ниже и '
+                                    'закажите заново!', parse_mode=types.ParseMode.MARKDOWN,
+                               reply_markup=keyboard2)
+    else:
+        await message.answer("Эта команда доступна к использованию *только в чатах*", types.ParseMode.MARKDOWN)
+
+
+@dp.message_handler(commands="del_group")
+async def delg(message: types.Message):
+    if 0 < int(message.chat.id):
+        user_id = message.from_user.id
+        if du.user_exists(user_id):
+            user_id = du.get_user_id(user_id)
+            if db.user_main_exists(user_id):
+                keyboard = {"inline_keyboard": [[{"text": "Подтвердить удаление", "callback_data": "del"}]]}
+                await bot.send_message(chat_id=message.chat.id,
+                                       text='Вы точно хотите удалить статистику и связку групп?',
+                                       parse_mode=types.ParseMode.MARKDOWN, reply_markup=keyboard)
+            else:
+                await message.answer("У вас нет связки групп для их удаления!")
+        else:
+            await message.answer("У вас нет связки групп для их удаления!")
+    else:
+        await message.answer("Эта команда доступна к использованию *только в личном чате*", types.ParseMode.MARKDOWN)
+
+
+@dp.message_handler(commands="add_group")
+async def addg(message: types.Message):
+    if 0 < int(message.chat.id):
+        user_id = message.from_user.id
+        flag = False
+
+        if not du.user_exists(user_id):
+            du.add_user(user_id)
+
+            user_id = du.get_user_id(user_id)
+            all_cods = db.all_cods()
+
+            cod1 = random.randint(1000, 9999)
+            while cod1 in all_cods[0]:
+                cod1 = random.randint(1000, 9999)
+
+            cod2 = random.randint(1000, 9999)
+            while cod2 in all_cods[1]:
+                cod2 = random.randint(1000, 9999)
+
+            db.add_user_tranzit(user_id, cod1, cod2)
+            await message.answer(f"Введите этот код в группе с учениками - *{str(cod1)}*, а этот в личной для "
+                                 f"фиксации заказа - *{str(cod2)}*", types.ParseMode.MARKDOWN)
+            flag = True
+        else:
+            user_id = du.get_user_id(user_id)
+            if db.user_tranzit_exists(user_id):
+                cods = db.get_cods(user_id)
+                await message.answer(f"Введите этот код в основной группе с учениками - *{str(cods[0])}*, а этот в "
+                                     f"личной для фиксации заказа - *{str(cods[1])}*", types.ParseMode.MARKDOWN)
+                flag = True
+            else:
+                if not db.user_main_exists(user_id):
+                    all_cods = db.all_cods()
+
+                    cod1 = random.randint(1000, 9999)
+                    while cod1 in all_cods[0]:
+                        cod1 = random.randint(1000, 9999)
+
+                    cod2 = random.randint(1000, 9999)
+                    while cod2 in all_cods[1]:
+                        cod2 = random.randint(1000, 9999)
+
+                    db.add_user_tranzit(user_id, cod1, cod2)
+                    await message.answer(f"Введите этот код в группе с учениками - *{str(cod1)}*, а этот в личной для "
+                                         f"фиксации заказа - *{str(cod2)}*", types.ParseMode.MARKDOWN)
+                    flag = True
+                else:
+                    await message.answer("У вас уже есть связка группы, вам надо её удалить, прежде чем верифицировать "
+                                         "новую!", types.ParseMode.MARKDOWN)
+
+        if flag:
+            keyboard = {"inline_keyboard": [[{"text": "Отменить верификацию", "callback_data": "cnl"}]]}
+            await bot.send_message(chat_id=message.chat.id,
+                                   text='*Вы можете отменить заявку* если не хотите связывать группы для сбора '
+                                        'заказов питания!', parse_mode=types.ParseMode.MARKDOWN, reply_markup=keyboard)
+    else:
+        await message.answer("Эта команда доступна к использованию *только в личном чате*", types.ParseMode.MARKDOWN)
+
+
+@dp.message_handler(commands=["today", "tomorrow"])
+async def todtom(message: types.Message):
+    food = pars.eating(0 if "today" in message.text else 1)
+    if food[0]:
+        food = food[1]
+
+        if "today" in message.text:
+            et = f"<b>Питание за {'.'.join(reversed(str(dt.date.today()).split('-')))}</b>\n\n"
+        else:
+            et = f"<b>Питание за {'.'.join(reversed(str(dt.date.today() + dt.timedelta(days=1)).split('-')))}</b>\n\n"
+
+        for j in food:
+            et = et + "<i><b>" + str(j) + ":</b></i>\n"
+            for i in food[j]:
+                et = et + "<b>* " + str(i[0]) + "</b> <i>[ "
+                et = et + str(i[1][0]) + " г. " + str(i[1][1]) + " ккал. ]</i>" + "\n"
+            et = et + "\n\n"
+
+        await message.answer(et, types.ParseMode.HTML)
+    else:
+        if food[1]:
+            await message.answer(f"<b>Ошибка в системе бота!</b>\n\nОна будет в скором времени исправлена...",
+                                 types.ParseMode.HTML)
+            await bot.send_message(chat_id=base.TEX_GROUP, text=f"<b>[ {str(dt.datetime.now())[:-10]} ]</b> "
+                                                                f"<b><i>=></i></b> <i>{food[3]}</i> (ошибка в системе)",
+                                   parse_mode=types.ParseMode.HTML)
+        else:
+            if food[2] != 6:
+                await message.answer(f"<b>Нет данных по питанию!</b>\n\nКак только данные появятся вы сможете "
+                                     f"их получить этой же командой!", types.ParseMode.HTML)
+                await bot.send_message(chat_id=base.TEX_GROUP, text=f"<b>[ {str(dt.datetime.now())[:-10]} ]</b> "
+                                                                    f"<b><i>=></i></b> <i>{food[3]}</i> (нет данных по "
+                                                                    f"питанию)", parse_mode=types.ParseMode.HTML)
+            else:
+                await message.answer(f"<b>Вы вызывете команду в воскресенье!</b>\n\nНа что вы надеетесь?",
+                                     types.ParseMode.HTML)
+
+
+# ИЛАЙН КЛАВИАТУРА
+@dp.callback_query_handler(text=["z", "o", "p", "zo", "zp", "op", "zop"])
+async def var(call: types.CallbackQuery):
+    et = {"z": "завтрак", "o": "обед", "p": "полдник", "zo": "завтрак / обед", "zp": "завтрак / полдник",
+          "op": "обед / полдник", "zop": "завтрак / обед / полдник"}
+
+    group_id = call.message.chat.id
+    if du.group_exists(group_id):
+        group_id = du.get_group_id(group_id)
+        if db.main_group_exists(group_id):
+
+            for i in str(call.data):
+                db.upd_stat_group(group_id, i)
+
+            ids = db.get_spec_group(group_id)
+            await bot.send_message(chat_id=str(du.get_first_group_id(ids)),
+                                   text=f'[{call.from_user.first_name}](tg://user?id={call.from_user.id}) >> '
+                                        f'*{et[call.data].title()}*', parse_mode=types.ParseMode.MARKDOWN)
+
+            await call.message.answer(text=f'{call.from_user.first_name}, всё принято, вы заказили - '
+                                           f'*{"и".join(et[call.data].split("/"))}*',
+                                      parse_mode=types.ParseMode.MARKDOWN)
+        else:
+            await call.message.answer(text=f'Вы ещё не можете использовать бота, завершите процедуру регистрации!',
+                                      parse_mode=types.ParseMode.MARKDOWN)
+    else:
+        await call.message.answer(text=f'Вы должны через личные сообщения зарегистрировать этот чат у бота вместе с '
+                                       f'дополнительным для отправки списка!', parse_mode=types.ParseMode.MARKDOWN)
+
+
+@dp.callback_query_handler(text=["cnl"])
+async def cnl(call: types.CallbackQuery):
+    user_id = du.get_user_id(call.message.chat.id)
+    if db.user_tranzit_exists(user_id):
+        db.delete_tranzit(user_id)
+        await call.message.answer('<b>Заявка удалена!</b> Если ещё захотите связать группы, то зановой вызовите '
+                                  'команду <b>/add_group</b>', types.ParseMode.HTML)
+    else:
+        await call.message.answer('У вас нет оставленных заявок!')
+
+
+@dp.callback_query_handler(text=["del"])
+async def ver_del(call: types.CallbackQuery):
+    user_id = du.get_user_id(call.message.chat.id)
+    if db.user_main_exists(user_id):
+        ids = db.get_main_group(user_id)
+        db.delete_main_group(user_id)
+        dg.delete_group(str(ids))
+        await call.message.answer('Всё успешно удалено!')
+    else:
+        await call.message.answer("У вас нет связки групп для их удаления!")
+
+
+@dp.callback_query_handler(text=["cancel"])
+async def cancel(call: types.CallbackQuery):
+    pass
+
+
+# ТРЕКЕР НОВЫХ ПОЛЬЗОВАТЕЛЕЙ
+@dp.message_handler(content_types=["text", "audio", "document", "photo", "sticker", "video",
+                                   "video_note", "voice", "location", "contact"])
+async def check(message: types.Message):
+    if 0 > int(message.chat.id):
+        if du.user_exists(message.from_user.id):
+            user_id = du.get_user_id(message.from_user.id)
+            if db.user_tranzit_exists(user_id) and len(message.text) == 4:
+                cods = db.get_cods(user_id)
+
+                flag = False
+
+                if not du.group_exists(message.chat.id):
+                    if message.text == str(cods[0]):
+                        du.add_group(message.chat.id)
+                        group_id = du.get_group_id(message.chat.id)
+                        db.add_main_group(user_id, group_id)
+                        flag = True
+                    elif message.text == str(cods[1]):
+                        du.add_group(message.chat.id)
+                        group_id = du.get_group_id(message.chat.id)
+                        db.add_set_group(user_id, group_id)
+                        flag = True
+                else:
+                    group_id = du.get_group_id(message.chat.id)
+                    if not db.main_group_exists(group_id):
+                        if message.text == str(cods[0]):
+                            db.add_main_group(user_id, group_id)
+                            flag = True
+                        elif message.text == str(cods[1]):
+                            db.add_set_group(user_id, group_id)
+                            flag = True
+
+                if flag and db.user_tranzit(user_id):
+                    ids = db.get_groups_ids(user_id)
+                    db.add_active_groups(user_id, ids[0], ids[1])
+                    db.delete_tranzit(user_id)
+                    dg.created_group(ids[0])
+                    dg.add_user(ids[0], user_id, message.from_user.first_name)
+        else:
+            if du.group_exists(message.chat.id):
+                group_id = du.get_group_id(message.chat.id)
+                if db.main_group_exists(group_id):
+                    du.add_user(message.from_user.id)
+                    user_id = du.get_user_id(message.from_user.id)
+                    dg.add_user(group_id, user_id, message.from_user.first_name)
+
+
+# ОТДЕЛЕНИЕ ДНЯ В ГРУППЕ
+async def time(wait_for):
+    while True:
+        await asyncio.sleep(wait_for)
+
+        hour = dt.datetime.now().hour
+        date = dt.datetime.now().day
+        wkd = dt.datetime.today().weekday()
+
+        data = db.get_day()
+
+        if date != data and hour == 11:
+            for ids in db.get_spec_groups():
+                group = du.get_first_group_id(ids[0])
+
+                if wkd == 5:
+                    dat = ".".join(reversed(str(dt.date.today() + dt.timedelta(days=2)).split("-")))
+                    await bot.send_message(chat_id=group, text=f'<b>Питание на {dat}</b>',
+                                           parse_mode=types.ParseMode.HTML)
+                elif wkd != 6:
+                    dat = ".".join(reversed(str(dt.date.today() + dt.timedelta(days=1)).split("-")))
+                    await bot.send_message(chat_id=group, text=f'<b>Питание на {dat}</b>',
+                                           parse_mode=types.ParseMode.HTML)
+
+            db.update_day(date)
+            os.remove("now.db")
+            file = open("now.db")
+            file.close()
+
+
+if __name__ == '__main__':
+    loop = asyncio.get_event_loop()
+    loop.create_task(time(600))  # ПРОВЕРКА КАЖДЫЕ 10 МИНУТ
+    executor.start_polling(dp, skip_updates=True)

code/pars.py

@@ -0,0 +1,52 @@
+import requests as req
+import datetime as dt
+import openpyxl, os, re
+
+
+def eating(day):
+    if day == 0:
+        wkd = dt.datetime.today().weekday()
+    else:
+        wkd = (dt.date.today() + dt.timedelta(days=1)).weekday()
+
+    if wkd != 6:
+        flag = False
+        try:
+            if day == 0:
+                eat = f"https://www.school01.ru/food/{str(dt.date.today())}-sm.xlsx"
+            else:
+                eat = f"https://www.school01.ru/food/{str(dt.date.today() + dt.timedelta(days=1))}-sm.xlsx"
+
+            file, xls = open("school_food.xlsx", "wb"), req.get(eat)
+            file.write(xls.content)
+            file.close()
+
+            excel_file = openpyxl.load_workbook('school_food.xlsx')
+            employees_sheet = excel_file[excel_file.sheetnames[0]]
+
+            food = {employees_sheet["A4"].value: [], employees_sheet["A12"].value: []}
+            food_info = [[employees_sheet["A4"].value, 4, 8], [employees_sheet["A12"].value, 12, 9]]
+
+            flag = True
+
+            if employees_sheet["A22"].value is not None:
+                food[employees_sheet["A22"].value] = []
+                food_info.append([employees_sheet["A22"].value, 21, 2])
+
+            for j in food_info:
+                for i in range(j[2]):
+                    if employees_sheet[f"D{j[1] + i}"].value is None:
+                        continue
+
+                    gramm = str(int(eval(str(employees_sheet[f"E{j[1] + i}"].value).strip())))
+                    kkal = str(eval("".join(str(employees_sheet[f"J{j[1] + i}"].value).split()).replace(",", ".", 1)))
+
+                    food[j[0]].append([employees_sheet[f"D{j[1] + i}"].value, [gramm, kkal]])
+
+            os.remove("school_food.xlsx")
+
+            return [True, food]
+        except Exception as e:
+            return [False, flag, wkd, repr(e)]
+    else:
+        return [False, False, wkd]

code/sql.py

@@ -0,0 +1,310 @@
+import sqlite3
+
+
+class Base:
+    def __init__(self, database):
+        """Подключаемся к БД и сохраняем курсор соединения"""
+        self.connection = sqlite3.connect(database)
+        self.cursor = self.connection.cursor()
+
+    # ДЕНЬ
+    def get_day(self):
+        """Получаем день"""
+        with self.connection:
+            return self.cursor.execute(f'SELECT `day` FROM `day`').fetchone()[0]
+
+    def update_day(self, day):
+        """Обновляем день"""
+        with self.connection:
+            return self.cursor.execute("UPDATE `day` SET `day` = ?", (day,))
+
+    # ТРАНЗИТ
+    def user_tranzit_exists(self, user_id):
+        """Проверяем, есть ли уже пользователь в базе"""
+        with self.connection:
+            result = self.cursor.execute(f'SELECT * FROM `tranz` WHERE `user_id` = ?', (user_id,)).fetchall()
+            return bool(len(result))
+
+    def add_user_tranzit(self, user_id, main, sett):
+        """Добавляем нового пользователя в транзит"""
+        with self.connection:
+            return self.cursor.execute(f"INSERT INTO `tranz` (`user_id`, `main_group_cod`, `main_group`, "
+                                       f"`set_group_cod`, `set_group`) VALUES(?,?,?,?,?)",
+                                       (str(user_id), str(main), None, str(sett), None))
+
+    def add_main_group(self, user_id, group_id):
+        """Добавляем главную группу"""
+        with self.connection:
+            return self.cursor.execute("UPDATE `tranz` SET `main_group` = ? WHERE `user_id` = ?", (group_id, user_id))
+
+    def add_set_group(self, user_id, group_id):
+        """Добавляем дополнительную группу"""
+        with self.connection:
+            return self.cursor.execute("UPDATE `tranz` SET `set_group` = ? WHERE `user_id` = ?", (group_id, user_id))
+
+    def all_cods(self):
+        """Список всех выданных кодов"""
+        with self.connection:
+            main = [i[0] for i in self.cursor.execute(f'SELECT main_group_cod FROM `tranz`').fetchall()]
+            sett = [i[0] for i in self.cursor.execute(f'SELECT set_group_cod FROM `tranz`').fetchall()]
+            return [main, sett]
+
+    def get_cods(self, user_id):
+        """Выданные коды"""
+        with self.connection:
+            main = self.cursor.execute(f'SELECT main_group_cod FROM `tranz` WHERE `user_id` = ?',
+                                       (user_id,)).fetchone()[0]
+            sett = self.cursor.execute(f'SELECT set_group_cod FROM `tranz` WHERE `user_id` = ?',
+                                       (user_id,)).fetchone()[0]
+            return [main, sett]
+
+    def user_tranzit(self, user_id):
+        """Проверка на заполненость"""
+        with self.connection:
+            result = self.cursor.execute(f'SELECT `main_group`, `set_group` FROM `tranz` WHERE `user_id` = ?',
+                                         (user_id,)).fetchone()
+            return None not in result
+
+    def get_groups_ids(self, user_id):
+        """Получение айди групп"""
+        with self.connection:
+            return self.cursor.execute(f'SELECT `main_group`, `set_group` FROM `tranz` WHERE `user_id` = ?',
+                                       (user_id,)).fetchone()
+
+    def delete_tranzit(self, user_id):
+        """Удаление ненужного транзита"""
+        with self.connection:
+            return self.cursor.execute(f'DELETE FROM `tranz` WHERE `user_id` = ?', (user_id,))
+
+    # ОСНОВНА
+    def add_active_groups(self, user_id, main, sett):
+        """Добавляем нового пользователя из транзита"""
+        with self.connection:
+            return self.cursor.execute(f"INSERT INTO `main` (`user_id`, `main_group_id`, `set_group_id`, `zav`, "
+                                       f"`obe`, `pol`) VALUES(?,?,?,?,?,?)", (user_id, main, sett, 0, 0, 0))
+
+    def main_group_exists(self, group_id):
+        """Проверяем, есть ли уже пользователь в базе"""
+        with self.connection:
+            result = self.cursor.execute(f'SELECT * FROM `main` WHERE `main_group_id` = ?', (group_id,)).fetchall()
+            return bool(len(result))
+
+    def get_spec_group(self, group_id):
+        """Получение айди групп"""
+        with self.connection:
+            return self.cursor.execute(f'SELECT `set_group_id` FROM `main` WHERE `main_group_id` = ?',
+                                       (group_id,)).fetchone()[0]
+
+    def get_main_group(self, user_id):
+        """Получение айди групп"""
+        with self.connection:
+            return self.cursor.execute(f'SELECT `main_group_id` FROM `main` WHERE `user_id` = ?',
+                                       (user_id,)).fetchone()[0]
+
+    def get_spec_groups(self):
+        """Получаем все технические группы"""
+        with self.connection:
+            return self.cursor.execute("SELECT `set_group_id` FROM `main`").fetchall()
+
+    def user_main_exists(self, user_id):
+        """Проверяем, есть ли уже пользователь в базе"""
+        with self.connection:
+            result = self.cursor.execute(f'SELECT * FROM `main` WHERE `user_id` = ?', (user_id,)).fetchall()
+            return bool(len(result))
+
+    def delete_main_group(self, user_id):
+        """Удаление ненужного транзита"""
+        with self.connection:
+            return self.cursor.execute(f'DELETE FROM `main` WHERE `user_id` = ?', (user_id,))
+
+    def upd_stat_group(self, group_id, var):
+        """Обновляем статистику"""
+        with self.connection:
+            self.cursor.execute("SELECT `zav`, `obe`, `pol` FROM `main` WHERE `main_group_id` = ?", (group_id,))
+            if var == "z":
+                return self.cursor.execute("UPDATE `main` SET `zav` = ? WHERE `main_group_id` = ?",
+                                           ((self.cursor.fetchone()[0] + 1), group_id))
+            elif var == 'o':
+                return self.cursor.execute("UPDATE `main` SET `obe` = ? WHERE `main_group_id` = ?",
+                                           ((self.cursor.fetchone()[1] + 1), group_id))
+            elif var == 'p':
+                return self.cursor.execute("UPDATE `main` SET `pol` = ? WHERE `main_group_id` = ?",
+                                           ((self.cursor.fetchone()[2] + 1), group_id))
+
+    #
+    def update_status_group(self, id_group, status):
+        """Обновляем статус группы"""
+        with self.connection:
+            return self.cursor.execute("UPDATE `group` SET `status` = ? WHERE `id_group` = ?", (status, id_group))
+
+    def get_group(self, status=True):
+        """Получаем все активные группы"""
+        with self.connection:
+            return self.cursor.execute("SELECT * FROM `group` WHERE `status` = ?", (status,)).fetchall()
+
+    def id_group_lst(self, status=True):
+        """Список айди активных групп"""
+        with self.connection:
+            return [i[1] for i in self.cursor.execute("SELECT * FROM `group` WHERE `status` = ?", (status,)).fetchall()]
+
+    def stat_element_group(self, id_group):
+        """Получение данных группы"""
+        with self.connection:
+            self.cursor.execute("SELECT * FROM `group` WHERE `id_group` = ?", (id_group,))
+            data = self.cursor.fetchone()
+            time, message, reply, command, url = int(data[3]), int(data[4]), int(data[5]), int(data[6]), int(data[7])
+            tik_tok, media, sticker, voice = int(data[8]), int(data[9]), int(data[10]), int(data[11])
+            bol, cool = int(data[12]), int(data[13])
+            return [message, reply, command, url, tik_tok, media, sticker, voice, time, bol, cool]
+
+    def id_lst(self, db):
+        """Список айди"""
+        with self.connection:
+            return [i[0] for i in self.cursor.execute(f'SELECT id_user FROM `{db}`').fetchall()]
+
+    def name_lst(self, db):
+        """Список имён"""
+        with self.connection:
+            return [i[0] for i in self.cursor.execute(f'SELECT first_name FROM `{db}`').fetchall()]
+
+    # ЗАВЕРШЕНИЕ
+    def close(self):
+        """Закрываем соединение с БД"""
+        self.connection.close()
+
+
+class User:
+    def __init__(self, database):
+        """Подключаемся к БД и сохраняем курсор соединения"""
+        self.connection = sqlite3.connect(database)
+        self.cursor = self.connection.cursor()
+
+    # СВЯЗКА ПОЛЬЗОВАТЕЛЯ
+    def user_exists(self, user_id):
+        """Проверяем, есть ли уже пользователь в базе"""
+        with self.connection:
+            result = self.cursor.execute(f'SELECT * FROM `users` WHERE `user_id` = ?', (user_id,)).fetchall()
+            return bool(len(result))
+
+    def add_user(self, user_id):
+        """Добавляем нового пользователя"""
+        with self.connection:
+            return self.cursor.execute(f"INSERT INTO `users` (`user_id`) VALUES(?)", (user_id,))
+
+    def get_user_id(self, user_id):
+        """Получаем короткое айди юзера"""
+        with self.connection:
+            return self.cursor.execute(f'SELECT `id` FROM `users` WHERE `user_id` = ?', (user_id,)).fetchone()[0]
+
+    # СВЯЗКА ГРУППЫ
+    def group_exists(self, group_id):
+        """Проверяем, есть ли уже группа в базе"""
+        with self.connection:
+            result = self.cursor.execute('SELECT * FROM `groups` WHERE `group_id` = ?', (group_id,)).fetchall()
+            return bool(len(result))
+
+    def add_group(self, group_id):
+        """Добавляем новую группу в таблицу"""
+        with self.connection:
+            return self.cursor.execute("INSERT INTO `groups` (`group_id`) VALUES(?)", (group_id,))
+
+    def get_group_id(self, group_id):
+        """Получаем короткое айди юзера"""
+        with self.connection:
+            return self.cursor.execute(f'SELECT `id` FROM `groups` WHERE `group_id` = ?', (group_id,)).fetchone()[0]
+
+    def get_first_group_id(self, group_id):
+        """Получаем длинное айди юзера"""
+        with self.connection:
+            return self.cursor.execute(f'SELECT `group_id` FROM `groups` WHERE `id` = ?', (group_id,)).fetchone()[0]
+
+    def update_group_id(self, from_id, to_id):
+        """Заменяем на новый айди"""
+        with self.connection:
+            return self.cursor.execute("UPDATE `groups` SET `group_id` = ? WHERE `group_id` = ?", (to_id, from_id))
+
+    # ЗАВЕРШЕНИЕ
+    def close(self):
+        """Закрываем соединение с БД"""
+        self.connection.close()
+
+
+class Group:
+    def __init__(self, database):
+        """Подключаемся к БД и сохраняем курсор соединения"""
+        self.connection = sqlite3.connect(database)
+        self.cursor = self.connection.cursor()
+
+    def created_group(self, group_id):
+        """Создаём новую таблицу"""
+        with self.connection:
+            return self.cursor.execute(f"""CREATE TABLE IF NOT EXISTS [{group_id}] (
+                                            user_id    INTEGER     NOT NULL,
+                                            first_name STRING (40) NOT NULL,
+                                            zav        INTEGER     NULL,
+                                            obe        INTEGER     NULL,
+                                            pol        INTEGER     NULL
+                                            );""")
+
+    def add_user(self, group_id, user_id, first_name):
+        """Добавляем нового пользователя"""
+        with self.connection:
+            return self.cursor.execute(f"INSERT INTO `{group_id}` (`user_id`, `first_name`, `zav`, `obe`, `pol`) "
+                                       f"VALUES(?,?,?,?,?)", (user_id, first_name, 0, 0, 0))
+
+    def update_name(self, user_id, name, group_id):
+        """Обновляем имя пользователя"""
+        with self.connection:
+            return self.cursor.execute(f"UPDATE `{group_id}` SET `first_name` = ? WHERE `user_id` = ?", (name, user_id))
+
+    def delete_group(self, group_id):
+        """Удаление таблицы с информацией"""
+        with self.connection:
+            return self.cursor.execute(f"DROP TABLE IF EXISTS [{group_id}]")
+
+    def close(self):
+        """Закрываем соединение с БД"""
+        self.connection.close()
+
+
+class Now:
+    def __init__(self, database):
+        """Подключаемся к БД и сохраняем курсор соединения"""
+        self.connection = sqlite3.connect(database)
+        self.cursor = self.connection.cursor()
+
+    def created_group(self, group_id):
+        """Создаём новую таблицу"""
+        with self.connection:
+            return self.cursor.execute(f"""CREATE TABLE IF NOT EXISTS [{group_id}] (
+                                            user_id      INTEGER    NOT NULL,
+                                            main_mess_id INTEGER    NOT NULL,
+                                            set_mess_id  INTEGER    NOT NULL,
+                                            ord_id       STRING (1) NOT NULL
+                                            );""")
+
+    def add_user(self, group_id, user_id, main_mess, set_mess, ord_id):
+        """Добавляем нового пользователя"""
+        with self.connection:
+            return self.cursor.execute(f"INSERT INTO `{group_id}` (`user_id`, `main_mess_id`, `set_mess_id`, `ord_id `)"
+                                       f" VALUES(?,?,?,?)", (user_id, main_mess, set_mess, ord_id))
+
+    def delete_group(self, group_id):
+        """Удаление таблицы с информацией"""
+        with self.connection:
+            return self.cursor.execute(f"DROP TABLE IF EXISTS [{group_id}]")
+
+    def check_user(self, group_id, user_id):
+        """Проверяем, есть ли уже юзер в базе"""
+        with self.connection:
+            result = self.cursor.execute(f'SELECT * FROM `{group_id}` WHERE `user_id` = ?', (user_id,)).fetchall()
+            return bool(len(result))
+
+    def check_group(self):
+        """Проверка на наличие таблицы с заказами"""
+        with self.connection:
+            pass
+
+    def close(self):
+        """Закрываем соединение с БД"""
+        self.connection.close()