v. 1.0

code/base.py

@@ -1,4 +1,4 @@
-TOKEN = "-"
+TOKEN = "5164296616:AAHwvadm3BrUovhPk8ceKHbPctg654XGkyU"
 
-ID_BOT = **********
-TEX_GROUP = "-*********"
+ID_BOT = 5164296616
+TEX_GROUP = "-700432173"

code/bot.py

@@ -1,4 +1,4 @@
-import logging, asyncio, random
+import logging, asyncio, random, pymorphy2
 import base, pars, sql, os
 import datetime as dt
 
@@ -6,23 +6,27 @@ from aiogram import Bot, Dispatcher, executor, types
 
 # log level
 logging.basicConfig(level=logging.INFO)
+morph = pymorphy2.MorphAnalyzer()
 
 # bot init
 bot = Bot(token=base.TOKEN)
 dp = Dispatcher(bot)
 
+# create now.db
+file = open('../db/now.db', 'w+')
+file.close()
+
 # 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)
+    if 0 < int(message.chat.id):
+        await message.answer("Ghdbtn", types.ParseMode.MARKDOWN)
 
 
 # ОБНОВЛЕНИЕ АЙДИ ГРУППЫ
@@ -35,12 +39,50 @@ async def chat_reload(message: types.Message):
 # КОМАНДЫ
 @dp.message_handler(commands="help")
 async def hlp(message: types.Message):
+    if 0 < int(message.chat.id):
         await message.answer("*Инструкция использования:*\n\n"
                              "*/eat* - с помощью этой команды вы можете заказать питание\n"
                              "*/today* - команда выдающая меню на сегодня\n"
                              "*/tomorrow* - команда выдающая меню на завтра\n\n"
                              "*/add_group* - команда выдающая меню на завтра\n"
                              "*/del_group* - команда выдающая меню на завтра\n", types.ParseMode.MARKDOWN)
+    else:
+        await message.answer("*Инструкция использования:*\n\n"
+                             "*/eat* - с помощью этой команды вы можете заказать питание\n"
+                             "*/today* - команда выдающая меню на сегодня\n"
+                             "*/tomorrow* - команда выдающая меню на завтра\n", types.ParseMode.MARKDOWN)
+
+
+@dp.message_handler(commands="stat")
+async def stat(message: types.Message):
+    if 0 > int(message.chat.id):
+        group_id = message.chat.id
+        if du.group_exists(group_id):
+            group_id = du.get_group_id(group_id)
+            if db.main_group_exists(group_id):
+                overall = db.stat_group(group_id)
+                all_users = dg.stat_all_users(group_id)
+
+                z = [[user[1], user[0]] for user in all_users if user[1] != 0]
+                o = [[user[2], user[0]] for user in all_users if user[2] != 0]
+                p = [[user[3], user[0]] for user in all_users if user[3] != 0]
+
+                txt = f"<i><b>Всего было сделано заказов - {sum(overall)}</b></i>\n"
+                line = morph.parse('заказ')[0]
+
+                lst = [[f"\n\t<b>* Завтраков - {str(overall[0])}</b>\n", z], [f"\n\t<b>* Обедов - {str(overall[1])}</b>\n", o],
+                       [f"\n\t<b>* Полдников - {str(overall[2])}</b>\n", p]]
+                for i in lst:
+                    txt = txt + i[0]
+                    if i[1]:
+                        for n, j in enumerate(i[1][:3]):
+                            txt = txt + "\t\t\t<b>" + str(n + 1) + ". " + j[1] + "</b> " + str(j[0]) + " " + line.make_agree_with_number(j[0]).word + "\n"
+
+                await message.answer(txt, types.ParseMode.HTML)
+            else:
+                await message.answer("Ваша группа не зарегистрирована!")
+        else:
+            await message.answer("Ваша группа не зарегистрирована!")
 
 
 @dp.message_handler(commands="eat")
@@ -195,29 +237,51 @@ async def var(call: types.CallbackQuery):
     if du.group_exists(group_id):
         group_id = du.get_group_id(group_id)
         if db.main_group_exists(group_id):
+            user_id = call.from_user.id
+            if du.user_exists(user_id):
+                user_id = du.get_user_id(user_id)
+            else:
+                du.add_user(user_id)
+                user_id = du.get_user_id(user_id)
 
+            if db.check_group_inproc(group_id):
+                if not dn.check_user(group_id, user_id):
+                    flag = True
+                else:
+                    await call.message.answer(f"{call.from_user.first_name}, вы уже сделали заказ! Отмените его с "
+                                              f"помощью кнопки отмены!")
+                    flag = False
+            else:
+                dn.created_group(group_id)
+                db.add_group(group_id)
+                flag = True
+
+            if flag:
                 for i in str(call.data):
-                db.upd_stat_group(group_id, i)
+                    db.upd_stat_group(group_id, i, 1)
+                    dg.upd_stat_user(group_id, user_id, i, 1)
 
                 ids = db.get_spec_group(group_id)
-            await bot.send_message(chat_id=str(du.get_first_group_id(ids)),
+                msg1 = 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}, всё принято, вы заказили - '
+                msg2 = await call.message.answer(text=f'{call.from_user.first_name}, всё принято, вы заказили - '
                                                       f'*{"и".join(et[call.data].split("/"))}*',
                                                  parse_mode=types.ParseMode.MARKDOWN)
+
+                dn.add_user(group_id, user_id, msg2.message_id, msg1.message_id, str(call.data))
         else:
-            await call.message.answer(text=f'Вы ещё не можете использовать бота, завершите процедуру регистрации!',
-                                      parse_mode=types.ParseMode.MARKDOWN)
+            await call.message.answer('Вы должны через личные сообщения зарегистрировать этот чат у бота вместе с '
+                                      'дополнительным для отправки списка!')
     else:
-        await call.message.answer(text=f'Вы должны через личные сообщения зарегистрировать этот чат у бота вместе с '
-                                       f'дополнительным для отправки списка!', parse_mode=types.ParseMode.MARKDOWN)
+        await call.message.answer('Вы должны через личные сообщения зарегистрировать этот чат у бота вместе с '
+                                  'дополнительным для отправки списка!')
 
 
 @dp.callback_query_handler(text=["cnl"])
 async def cnl(call: types.CallbackQuery):
-    user_id = du.get_user_id(call.message.chat.id)
+    user_id = du.get_user_id(call.from_user.id)
     if db.user_tranzit_exists(user_id):
         db.delete_tranzit(user_id)
         await call.message.answer('<b>Заявка удалена!</b> Если ещё захотите связать группы, то зановой вызовите '
@@ -228,11 +292,12 @@ async def cnl(call: types.CallbackQuery):
 
 @dp.callback_query_handler(text=["del"])
 async def ver_del(call: types.CallbackQuery):
-    user_id = du.get_user_id(call.message.chat.id)
+    user_id = du.get_user_id(call.from_user.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))
+        db.del_group(str(ids))
         await call.message.answer('Всё успешно удалено!')
     else:
         await call.message.answer("У вас нет связки групп для их удаления!")
@@ -240,7 +305,44 @@ async def ver_del(call: types.CallbackQuery):
 
 @dp.callback_query_handler(text=["cancel"])
 async def cancel(call: types.CallbackQuery):
-    pass
+    group_id = call.message.chat.id
+    if du.group_exists(group_id):
+        main_group_id = group_id
+        group_id = du.get_group_id(group_id)
+        if db.main_group_exists(group_id):
+            user_id = call.from_user.id
+            if du.user_exists(user_id):
+                user_id = du.get_user_id(user_id)
+            else:
+                du.add_user(user_id)
+                user_id = du.get_user_id(user_id)
+
+            if db.check_group_inproc(group_id):
+                if dn.check_user(group_id, user_id):
+                    ord_id = dn.get_ord_id(group_id, user_id)
+
+                    for i in ord_id:
+                        db.upd_stat_group(group_id, i, -1)
+                        dg.upd_stat_user(group_id, user_id, i, -1)
+
+                    ids = db.get_spec_group(group_id)
+                    set_group_id = str(du.get_first_group_id(ids))
+
+                    main, sett = dn.get_message(group_id, user_id)
+                    await bot.delete_message(chat_id=main_group_id, message_id=main)
+                    await bot.delete_message(chat_id=set_group_id, message_id=sett)
+
+                    dn.del_user(group_id, user_id)
+                    await call.message.answer(f"{call.from_user.first_name}, ваш заказ отменён!")
+                else:
+                    await call.message.answer(f"{call.from_user.first_name}, у вас нет заказа!")
+            else:
+                await call.message.answer(f"{call.from_user.first_name}, у вас нет заказа!")
+        else:
+            await call.message.answer('Вы ещё не можете использовать бота, завершите процедуру регистрации!')
+    else:
+        await call.message.answer('Вы должны через личные сообщения зарегистрировать этот чат у бота вместе с '
+                                  'дополнительным для отправки списка!')
 
 
 # ТРЕКЕР НОВЫХ ПОЛЬЗОВАТЕЛЕЙ
@@ -282,6 +384,11 @@ async def check(message: types.Message):
                     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):
+                        dg.update_name(user_id, message.from_user.first_name, group_id)
         else:
             if du.group_exists(message.chat.id):
                 group_id = du.get_group_id(message.chat.id)
@@ -302,7 +409,7 @@ async def time(wait_for):
 
         data = db.get_day()
 
-        if date != data and hour == 11:
+        if date != data and hour == 6:
             for ids in db.get_spec_groups():
                 group = du.get_first_group_id(ids[0])
 
@@ -316,9 +423,11 @@ async def time(wait_for):
                                            parse_mode=types.ParseMode.HTML)
 
             db.update_day(date)
-            os.remove("now.db")
-            file = open("now.db")
-            file.close()
+            db.reset_proc()
+
+            os.remove('../db/now.db')
+            fle = open('../db/now.db', 'w+')
+            fle.close()
 
 
 if __name__ == '__main__':

code/sql.py

@@ -117,55 +117,47 @@ class Base:
         with self.connection:
             return self.cursor.execute(f'DELETE FROM `main` WHERE `user_id` = ?', (user_id,))
 
-    def upd_stat_group(self, group_id, var):
+    def upd_stat_group(self, group_id, var, count):
         """Обновляем статистику"""
         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))
+                                           ((self.cursor.fetchone()[0] + count), group_id))
             elif var == 'o':
                 return self.cursor.execute("UPDATE `main` SET `obe` = ? WHERE `main_group_id` = ?",
-                                           ((self.cursor.fetchone()[1] + 1), group_id))
+                                           ((self.cursor.fetchone()[1] + count), group_id))
             elif var == 'p':
                 return self.cursor.execute("UPDATE `main` SET `pol` = ? WHERE `main_group_id` = ?",
-                                           ((self.cursor.fetchone()[2] + 1), group_id))
+                                           ((self.cursor.fetchone()[2] + count), 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):
+    def stat_group(self, group_id):
         """Получение данных группы"""
         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]
+            return self.cursor.execute("SELECT `zav`, `obe`, `pol` FROM `main` WHERE `main_group_id` = ?",
+                                       (group_id,)).fetchone()
 
-    def id_lst(self, db):
-        """Список айди"""
+    # ПРОЦЕСС
+    def check_group_inproc(self, group_id):
+        """Проверка на наличие таблицы с заказами"""
         with self.connection:
-            return [i[0] for i in self.cursor.execute(f'SELECT id_user FROM `{db}`').fetchall()]
+            result = self.cursor.execute(f'SELECT * FROM `proc` WHERE `group_id` = ?', (group_id,)).fetchall()
+            return bool(len(result))
 
-    def name_lst(self, db):
-        """Список имён"""
+    def add_group(self, group_id):
+        """Добавляем нового пользователя из транзита"""
         with self.connection:
-            return [i[0] for i in self.cursor.execute(f'SELECT first_name FROM `{db}`').fetchall()]
+            return self.cursor.execute(f"INSERT INTO `proc` (`group_id`) VALUES(?)", (group_id,))
+
+    def reset_proc(self):
+        """Удаление всех групп"""
+        with self.connection:
+            return self.cursor.execute('DELETE FROM `proc`')
+
+    def del_group(self, group_id):
+        """Удаление ненужного транзита"""
+        with self.connection:
+            return self.cursor.execute(f'DELETE FROM `proc` WHERE `group_id` = ?', (group_id,))
 
     # ЗАВЕРШЕНИЕ
     def close(self):
@@ -262,6 +254,25 @@ class Group:
         with self.connection:
             return self.cursor.execute(f"DROP TABLE IF EXISTS [{group_id}]")
 
+    def upd_stat_user(self, group_id, user_id, var, count):
+        """Обновляем статистику"""
+        with self.connection:
+            self.cursor.execute(f"SELECT `zav`, `obe`, `pol` FROM `{group_id}` WHERE `user_id` = ?", (user_id,))
+            if var == "z":
+                return self.cursor.execute(f"UPDATE `{group_id}` SET `zav` = ? WHERE `user_id` = ?",
+                                           (str(self.cursor.fetchone()[0] + count), user_id))
+            elif var == 'o':
+                return self.cursor.execute(f"UPDATE `{group_id}` SET `obe` = ? WHERE `user_id` = ?",
+                                           (str(self.cursor.fetchone()[1] + count), user_id))
+            elif var == 'p':
+                return self.cursor.execute(f"UPDATE `{group_id}` SET `pol` = ? WHERE `user_id` = ?",
+                                           (str(self.cursor.fetchone()[2] + count), user_id))
+
+    def stat_all_users(self, group_id):
+        """Список имён"""
+        with self.connection:
+            return self.cursor.execute(f'SELECT `first_name`, `zav`, `obe`, `pol` FROM `{group_id}`').fetchall()
+
     def close(self):
         """Закрываем соединение с БД"""
         self.connection.close()
@@ -280,15 +291,20 @@ class Now:
                                             user_id      INTEGER    NOT NULL,
                                             main_mess_id INTEGER    NOT NULL,
                                             set_mess_id  INTEGER    NOT NULL,
-                                            ord_id       STRING (1) NOT NULL
+                                            ord_id       STRING     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 `)"
+            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 del_user(self, group_id, user_id):
+        """Удаление пользователя"""
+        with self.connection:
+            return self.cursor.execute(f'DELETE FROM `{group_id}` WHERE `user_id` = ?', (user_id,))
+
     def delete_group(self, group_id):
         """Удаление таблицы с информацией"""
         with self.connection:
@@ -300,10 +316,17 @@ class Now:
             result = self.cursor.execute(f'SELECT * FROM `{group_id}` WHERE `user_id` = ?', (user_id,)).fetchall()
             return bool(len(result))
 
-    def check_group(self):
-        """Проверка на наличие таблицы с заказами"""
+    def get_ord_id(self, group_id, user_id):
+        """Проверяем, есть ли уже юзер в базе"""
         with self.connection:
-            pass
+            return self.cursor.execute(f'SELECT `ord_id` FROM `{group_id}` WHERE `user_id` = ?',
+                                       (user_id,)).fetchone()[0]
+
+    def get_message(self, group_id, user_id):
+        """Проверяем, есть ли уже юзер в базе"""
+        with self.connection:
+            return self.cursor.execute(f'SELECT `main_mess_id`, `set_mess_id` FROM `{group_id}` WHERE `user_id` = ?',
+                                       (user_id,)).fetchone()
 
     def close(self):
         """Закрываем соединение с БД"""