refactor bot

db.py

@@ -41,6 +41,7 @@ console_handler = logging.StreamHandler()
 console_handler.setFormatter(formatter)
 logger.addHandler(console_handler)
 
+
 class BotDB:
 
     def __init__(self, db_file):
@@ -81,7 +82,8 @@ class BotDB:
         except sqlite3.Error as error:
             print(error)
 
-    def add_new_user_in_db(self, user_id, first_name, full_name, username, is_bot, language_code, date_added, date_changed):
+    def add_new_user_in_db(self, user_id, first_name, full_name, username, is_bot, language_code, date_added,
+                           date_changed):
         """Добавляем юзера в базу"""
         try:
             self.cursor.execute("INSERT INTO 'our_users' ('user_id', 'first_name', 'full_name', 'username', 'is_bot', "
@@ -92,7 +94,6 @@ class BotDB:
         except sqlite3.Error as error:
             print(error)
 
-
     def user_exists(self, user_id):
         """Проверяем, есть ли юзер в базе"""
         try:
@@ -101,7 +102,6 @@ class BotDB:
         except sqlite3.Error as error:
             print(error)
 
-
     def get_user_id(self, user_id):
         """Достаем id юзера в базе по его user_id"""
         try:
@@ -110,7 +110,6 @@ class BotDB:
         except sqlite3.Error as error:
             print(error)
 
-
     def get_username(self, user_id):
         """Достаем id юзера в базе по его user_id"""
         try:
@@ -138,7 +137,6 @@ class BotDB:
         except sqlite3.Error as error:
             print(error)
 
-
     def change_name(self, user_id):
         #TODO: реализовать функцию изменения имени пользователя по которому к нему обращается бот. ОБновляем поля first_name, date_changed
         #result = self.cursor.execute("UPDATE 'our_users' SET (?) WHERE user_id = (?)", (new_user_name), )
@@ -147,7 +145,9 @@ class BotDB:
     def add_audio_record(self, file_name, author_id, date_added, listen_count, file_id):
         """Добавляет информацию о войсе юзера в БД"""
         try:
-            result = self.cursor.execute("INSERT INTO `audio_message_reference` (file_name, author_id, date_added, listen_count, file_id) VALUES (?, ?, ?, ?, ?)", (file_name, author_id, date_added, listen_count, file_id))
+            result = self.cursor.execute(
+                "INSERT INTO `audio_message_reference` (file_name, author_id, date_added, listen_count, file_id) VALUES (?, ?, ?, ?, ?)",
+                (file_name, author_id, date_added, listen_count, file_id))
             return self.conn.commit()
         except sqlite3.Error as error:
             print(error)
@@ -161,11 +161,11 @@ class BotDB:
         except sqlite3.Error as error:
             print(error)
 
-
     def get_last_user_audio_record(self, user_id):
         """Получает данные о количестве записей пользователя"""
         try:
-            result = self.cursor.execute("SELECT `file_id` FROM `audio_message_reference` WHERE `author_id` = ?", (user_id,))
+            result = self.cursor.execute("SELECT `file_id` FROM `audio_message_reference` WHERE `author_id` = ?",
+                                         (user_id,))
             return bool(len(result.fetchall()))
         except sqlite3.Error as error:
             print(error)
@@ -173,7 +173,8 @@ class BotDB:
     def get_id_for_audio_record(self, user_id):
         """Получает ID аудио сообщения пользователя"""
         try:
-            result = self.cursor.execute("SELECT `file_id` FROM `audio_message_reference` WHERE `author_id` = ? ORDER BY date_added DESC LIMIT 1",
+            result = self.cursor.execute(
+                "SELECT `file_id` FROM `audio_message_reference` WHERE `author_id` = ? ORDER BY date_added DESC LIMIT 1",
                 (user_id,))
             return result.fetchone()[0]
         except sqlite3.Error as error:
@@ -182,7 +183,9 @@ class BotDB:
     def get_path_for_audio_record(self, user_id):
         """Получает данные о названии файла"""
         try:
-            result = self.cursor.execute("SELECT `file_name` FROM `audio_message_reference` WHERE `author_id` = ? ORDER BY date_added DESC LIMIT 1", (user_id,))
+            result = self.cursor.execute(
+                "SELECT `file_name` FROM `audio_message_reference` WHERE `author_id` = ? ORDER BY date_added DESC LIMIT 1",
+                (user_id,))
             return result.fetchone()[0]
         except sqlite3.Error as error:
             print(error)
@@ -197,7 +200,8 @@ class BotDB:
                 WHERE l.user_id = ?
                 AND l.file_name IS NOT NULL""", (user_id,))
             check_sign = query_listen_audio.fetchall()
-            query_all_audio = self.cursor.execute('SELECT file_name FROM audio_message_reference WHERE author_id <> ?', (user_id,))
+            query_all_audio = self.cursor.execute('SELECT file_name FROM audio_message_reference WHERE author_id <> ?',
+                                                  (user_id,))
             sign_all_audio = query_all_audio.fetchall()
             new_sign1 = list(set(sign_all_audio) - set(check_sign))
             new_sign = []
@@ -210,7 +214,9 @@ class BotDB:
     def mark_listened_audio(self, file_name, user_id):
         """Отмечает аудио прослушанным для конкретного пользователя."""
         try:
-            result = self.cursor.execute("INSERT INTO `listen_audio_users` (file_name, user_id, is_listen) VALUES (?, ?, ?)", (file_name, user_id, 1))
+            result = self.cursor.execute(
+                "INSERT INTO `listen_audio_users` (file_name, user_id, is_listen) VALUES (?, ?, ?)",
+                (file_name, user_id, 1))
             return self.conn.commit()
         except sqlite3.Error as error:
             print(error)
@@ -219,7 +225,8 @@ class BotDB:
         """Получает данные о получении стикеров пользователем"""
         try:
             result = self.cursor.execute("SELECT `has_stickers` FROM `our_users` WHERE `user_id` = ?", (user_id,))
-            return result.fetchone()[0]
+            return result.fetchone()[0] == 1
+            #return result.fetchone()[0]
         except sqlite3.Error as error:
             print(error)
 
@@ -243,7 +250,6 @@ class BotDB:
         except sqlite3.Error as error:
             print(error)
 
-
     def get_blacklist_users_by_filters(self):
         """Возвращает список пользователей в черном списке по фильтру"""
         return None
@@ -270,6 +276,25 @@ class BotDB:
             logger.error(f"Error delete user with ID {user_id} from blacklist table: {error}")
             return False
 
+    def add_new_message_in_db(self, message_text, user_id, message_id, date, has_answer):
+        """Добавляем сообщение юзера в базу"""
+        try:
+
+            self.cursor.execute(
+                "INSERT INTO `user_messages` (message_text, user_id, message_id, date, has_answer) VALUES (?, ?, ?, ?, ?)",
+                (message_text, message_id, user_id, date, has_answer))
+            return self.conn.commit()
+        except sqlite3.Error as error:
+            print(error)
+
+    def get_user_by_message_id(self, message_id):
+        """Возвращает идентификатор пользователя по идентификатору сообщения"""
+        try:
+            result = self.cursor.execute("SELECT user_id FROM `user_messages` WHERE message_id = ?", (message_id,))
+            return result.fetchone()[0]
+        except sqlite3.Error as error:
+            print(error)
+
     def close(self):
         """Закрываем соединение с БД"""
         self.conn.close()

main.py

@@ -3,7 +3,7 @@ import os
 import sys
 from pathlib import Path
 from time import sleep
-
+from enum import Enum
 import db
 from db import BotDB
 import telebot
@@ -32,10 +32,319 @@ LOGS = config.getboolean('Settings', 'logs')
 TEST = config.getboolean('Settings', 'test')
 
 # Инициализируем бота и базку
-bot = telebot.TeleBot(BOT_TOKEN, parse_mode=None)
 BotDB = BotDB('tg-bot-database')
 
 
+#TODO: state хранить в базе
+#TODO: Перенести обработчик коллбэков
+
+class State(Enum):
+    START = "START"
+    SUGGEST = "SUGGEST"
+    ADMIN = "ADMIN"
+    CHAT = "CHAT"
+    PRE_CHAT = "PRE_CHAT"
+
+
+class TelegramHelperBot:
+    def __init__(self, token):
+        self.bot = telebot.TeleBot(token)
+        self.state = State.START
+
+        # Router for user
+        @self.bot.message_handler(func=lambda message: True, chat_types=['private'])
+        def handle_message(message):
+            if self.state == State.START:
+                if message.text == '/start':
+                    print(f'Внутри функции handle_message // Команда /start // state - {self.state.value}')
+                    self.start_message(message)
+                elif message.text == '📢Предложить свой пост':
+                    print(f'Внутри функции handle_message // Команда /suggest // state - {self.state.value}')
+                    self.suggest_post(message)
+                    self.state = State.SUGGEST
+                elif message.text == '🤪Хочу стикеры':
+                    print(f'Внутри функции handle_message // Команда /stickers // state - {self.state.value}')
+                    self.stickers(message)
+                    self.state = State.START
+                elif message.text == '📩Связаться с админами':
+                    print(f'Внутри функции handle_message // Команда /connect // state - {self.state.value}')
+                    self.connect_with_admin(message)
+                    self.state = State.PRE_CHAT
+                    print(f'В state.START - {self.state.value}')
+                elif message.text == '👋🏼Сказать пока!':
+                    print(f'Внутри функции handle_message // Команда /end // state - {self.state.value}')
+                    self.end_message(message)
+                    self.state = State.START
+                elif message.text == 'Выйти из чата':
+                    print(f'Внутри функции handle_message // Команда /end // state - {self.state.value}')
+                    self.end_message(message)
+                elif message.text == '/admin':
+                    self.state = State.ADMIN
+                    #TODO: Админку сделать!
+                    self.bot.send_message(message.chat.id,
+                                          "Ты в админке, Ура! Делай что хочешь")
+                elif message.text == '/state':
+                    print(f'Внутри функции handle_message // Команда /state // state - {self.state.value}')
+                    self.bot.send_message(message.chat.id,
+                                          f'Твой state == {self.state.value}')
+                else:
+                    self.bot.send_message(message.chat.id,
+                                          "Не понимаю где ты находишься. Нажми /state, и я расскажу что ты можешь "
+                                          "сделать")
+
+            if self.state == State.SUGGEST:
+                self.bot.register_next_step_handler(message, self.resend_message_in_group_for_post)
+                self.state = State.START
+            elif self.state == State.PRE_CHAT:
+                self.bot.register_next_step_handler(message, self.resend_message_in_group_for_message)
+                self.state = State.START
+
+            if self.state == State.CHAT:
+                print(f'В state.CHAT - {self.state.value}')
+                if message.text == 'Выйти из чата':
+                    self.state = State.START
+                    self.end_message(message)
+                    print(f'Обработчик в CHAT     - {self.state.value}')
+                else:
+                    print(f'Обработчик чата в чате CHAT - {self.state.value}')
+                    self.resend_message_in_group_for_message(message)
+
+        @self.bot.message_handler(func=lambda message: True, chat_types=['group'])
+        def handle_message(message):
+            """Функция ответа админа пользователю через закрытый чат"""
+            self.state = State.CHAT
+            markup = types.ReplyKeyboardMarkup(resize_keyboard=True, one_time_keyboard=True)
+            item1 = types.KeyboardButton("Выйти из чата")
+            markup.add(item1)
+            message_id = message.reply_to_message.id
+            message_from_admin = message.text
+            chat_id = BotDB.get_user_by_message_id(message_id)
+            self.bot.send_message(chat_id, message_from_admin, reply_markup=markup)
+
+    def register_chat_handler(self, message):
+        self.bot.register_next_step_handler(message, self.resend_message_in_group_for_message)
+
+    def start(self):
+        while True:
+            try:
+                self.bot.polling(none_stop=True)
+            except (ConnectionError, Exception):
+                print(f"Произошла ошибка: {str(Exception)}\n\nTraceback:\n{traceback.format_exc()}")
+
+    def start_message(self, message):
+        try:
+            name_stick_hello = list(Path('Stick').rglob('Hello_*'))
+            random_stick_hello = open(random.choice(name_stick_hello), 'rb')
+            # logging
+            if LOGS:
+                self.bot.forward_message(chat_id=GROUP_FOR_LOGS,
+                                         from_chat_id=message.chat.id,
+                                         message_id=message.message_id)
+            self.bot.send_sticker(message.chat.id, random_stick_hello)
+            sleep(0.3)
+        except Exception as e:
+            print(f'{str(e)}')
+            if LOGS:
+                self.bot.send_message(IMPORTANT_LOGS,
+                                      f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
+
+        try:
+            user_id = message.from_user.id
+            first_name = message.from_user.first_name
+            full_name = message.from_user.full_name
+            is_bot = message.from_user.is_bot
+            username = message.from_user.username
+            language_code = message.from_user.language_code
+            date_added = datetime.now()
+            date_changed = date_added
+
+            if not BotDB.user_exists(user_id):
+                BotDB.add_new_user_in_db(user_id, first_name, full_name, username, is_bot, language_code, date_added,
+                                         date_changed)
+            markup = self.get_reply_keyboard(message)
+            hello_message = messages.get_message(self.__get_first_name(message), 'HELLO_MESSAGE')
+            self.bot.send_message(message.chat.id, hello_message, parse_mode='html', reply_markup=markup,
+                                  disable_web_page_preview=not PREVIEW_LINK)
+        except Exception as e:
+            print(f'{str(e)}')
+            if LOGS:
+                self.bot.send_message(IMPORTANT_LOGS,
+                                      f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
+
+    #TODO: При отправке более одного сообщения, не пересылает сообщение в чат, БАГ!!!!
+    def resend_message_in_group_for_message(self, message):
+        self.bot.forward_message(chat_id=GROUP_FOR_MESSAGE,
+                                 from_chat_id=message.chat.id,
+                                 message_id=message.message_id
+                                 )
+        print(f'Кладу в базу: {message.message_id}')
+        BotDB.add_new_message_in_db(message.text, message.message_id + 1, message.from_user.id, datetime.now(), 0)
+        question = messages.get_message(self.__get_first_name(message), 'QUESTION')
+        markup = types.ReplyKeyboardMarkup(resize_keyboard=True, one_time_keyboard=True)
+        item1 = types.KeyboardButton("Выйти из чата")
+        markup.add(item1)
+        self.bot.send_message(message.chat.id, question, parse_mode='html', disable_web_page_preview=not PREVIEW_LINK,
+                              reply_markup=markup)
+
+    def suggest_post(self, message):
+        try:
+            markup = types.ReplyKeyboardRemove()
+            suggest_news = messages.get_message(self.__get_first_name(message), 'SUGGEST_NEWS')
+            self.bot.send_message(message.chat.id, suggest_news, parse_mode='html')
+            sleep(0.3)
+            suggest_news_2 = messages.get_message(self.__get_first_name(message), 'SUGGEST_NEWS_2')
+            self.bot.send_message(message.chat.id, suggest_news_2, parse_mode='html', reply_markup=markup)
+        except Exception as e:
+            if LOGS:
+                self.bot.send_message(IMPORTANT_LOGS,
+                                      f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
+            # logging
+        if LOGS:
+            self.bot.forward_message(chat_id=GROUP_FOR_LOGS,
+                                     from_chat_id=message.chat.id,
+                                     message_id=message.message_id)
+
+    def stickers(self, message):
+        BotDB.update_info_about_stickers(user_id=message.from_user.id)
+        markup = self.get_reply_keyboard(message)
+        try:
+            self.bot.forward_message(chat_id=GROUP_FOR_LOGS,
+                                     from_chat_id=message.chat.id,
+                                     message_id=message.message_id)
+            self.bot.send_message(message.chat.id,
+                                  text='Хорошо, лови, добавить можно отсюда: https://t.me/addstickers/love_biysk',
+                                  reply_markup=markup)
+        except ApiTelegramException as e:
+            self.bot.send_message(chat_id=IMPORTANT_LOGS,
+                                  text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
+
+    def connect_with_admin(self, message):
+        connect_with_admin = messages.get_message(self.__get_first_name(message), 'CONNECT_WITH_ADMIN')
+        self.bot.send_message(message.chat.id, connect_with_admin, parse_mode="html")
+        # logging
+        if LOGS:
+            self.bot.forward_message(chat_id=GROUP_FOR_LOGS,
+                                     from_chat_id=message.chat.id,
+                                     message_id=message.message_id)
+
+    def end_message(self, message):
+        try:
+            name_stick_bye = list(Path('Stick').rglob('Universal_*'))
+            random_stick_bye = open(random.choice(name_stick_bye), 'rb')
+            self.bot.send_sticker(message.chat.id, random_stick_bye)
+        except ApiTelegramException as e:
+            if LOGS:
+                self.bot.send_message(chat_id=IMPORTANT_LOGS,
+                                      text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
+        markup = types.ReplyKeyboardRemove()
+        try:
+            bye_message = messages.get_message(self.__get_first_name(message), 'BYE_MESSAGE')
+            self.bot.send_message(message.chat.id, bye_message,
+                                  parse_mode='html', reply_markup=markup, disable_web_page_preview=not PREVIEW_LINK)
+        except Exception as e:
+            if LOGS:
+                self.bot.send_message(chat_id=IMPORTANT_LOGS,
+                                      text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
+        if LOGS:
+            # logging
+            self.bot.forward_message(chat_id=GROUP_FOR_LOGS,
+                                     from_chat_id=message.chat.id,
+                                     message_id=message.message_id)
+
+    def resend_message_in_group_for_post(self, message):
+        markup = types.InlineKeyboardMarkup(row_width=1)
+        item1 = types.InlineKeyboardButton("Опубликовать", callback_data='post_post_post')
+        item2 = types.InlineKeyboardButton("Отклонить", callback_data='decline')
+        markup.add(item1, item2)
+        try:
+            if message.content_type == 'text':
+                post_text = message.text.lower()
+                if post_text.find('неанон') != -1 or post_text.find('не анон') != -1:
+                    self.bot.send_message(
+                        # TODO: GROUP_FOR_POST
+                        chat_id=GROUP_FOR_POST,
+                        text=f'Пост из ТГ:\n{post_text}\n\nАвтор поста: {message.from_user.first_name} @{message.from_user.username}',
+                        reply_markup=markup
+                    )
+                elif post_text.find('анон') != -1:
+                    self.bot.send_message(
+                        # TODO: GROUP_FOR_POST
+                        chat_id=GROUP_FOR_POST,
+                        text=f'Пост из ТГ:\n{message.text}\n\nПост опубликован анонимно',
+                        reply_markup=markup
+                    )
+                else:
+                    self.bot.send_message(
+                        # TODO: GROUP_FOR_POST
+                        chat_id=GROUP_FOR_POST,
+                        text=f'Пост из ТГ:\n{post_text}\n\nАвтор поста: {message.from_user.first_name} @{message.from_user.username}',
+                        reply_markup=markup
+                    )
+            elif message.content_type == 'photo' and message.media_group_id is None:
+                post_text_for_photo = message.caption.lower()
+                if post_text_for_photo.find('неанон') != -1 or post_text_for_photo.find('не анон') != -1:
+                    self.bot.send_photo(
+                        # TODO: GROUP_FOR_POST
+                        chat_id=GROUP_FOR_POST,
+                        caption=f'Пост из ТГ:\n{post_text_for_photo}\n\nАвтор поста: {message.from_user.first_name} @{message.from_user.username}',
+                        photo=message.photo[-1].file_id,
+                        reply_markup=markup
+                    )
+                elif post_text_for_photo.find('анон') != -1 or post_text_for_photo.find('анон') != -1:
+                    self.bot.send_photo(
+                        # TODO: GROUP_FOR_POST
+                        chat_id=GROUP_FOR_POST,
+                        caption=f'Пост из ТГ:\n{post_text_for_photo}\n\nПост опубликован анонимно',
+                        photo=message.photo[-1].file_id,
+                        reply_markup=markup
+                    )
+                else:
+                    self.bot.send_photo(
+                        # TODO: GROUP_FOR_POST
+                        chat_id=GROUP_FOR_POST,
+                        caption=f'Пост из ТГ:\n{post_text_for_photo}\n\nАвтор поста: {message.from_user.first_name} @{message.from_user.username}',
+                        photo=message.photo[-1].file_id,
+                        reply_markup=markup
+                    )
+            # TODO: Не понятна реализация с альбомами от слова совсем
+            # elif message.content_type == 'photo' and message.media_group_id != None:
+            #    bot.forward_message(chat_id=IMPORTANT_LOGS, from_chat_id=message.chat.id, message_id=message.message_id )
+            else:
+                pass
+        except Exception as e:
+            if LOGS:
+                self.bot.send_message(chat_id=IMPORTANT_LOGS,
+                                      text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
+        markup_for_user = self.get_reply_keyboard(message)
+        success_send_message = messages.get_message(self.__get_first_name(message), 'SUCCESS_SEND_MESSAGE')
+        self.bot.send_message(message.chat.id, success_send_message, parse_mode='html',
+                              disable_web_page_preview=not PREVIEW_LINK, reply_markup=markup_for_user)
+
+    @staticmethod
+    def get_reply_keyboard(message):
+        markup = types.ReplyKeyboardMarkup(resize_keyboard=True, one_time_keyboard=True)
+        item1 = types.KeyboardButton("📢Предложить свой пост")
+        item2 = types.KeyboardButton("📩Связаться с админами")
+        item3 = types.KeyboardButton("👋🏼Сказать пока!")
+        #TODO: Есть ощущение что не совсем так работает как надо
+        item4 = types.KeyboardButton("🤪Хочу стикеры") if not BotDB.get_info_about_stickers(
+            user_id=message.from_user.id) else None
+
+        if item4:
+            markup.add(item1, item2, item3, item4)
+        else:
+            markup.add(item1, item2, item3)
+
+        return markup
+
+    @staticmethod
+    def __get_first_name(message):
+        return message.from_user.first_name
+
+
+bot = TelegramHelperBot(BOT_TOKEN)
+
+
 def telegram_bot():
     # Черный список
 
@@ -51,7 +360,6 @@ def telegram_bot():
         except Exception as e:
             bot.register_next_step_handler(message, admin_panel)
 
-
     def ban_user(message):
         # проверяем, что ID передан правильно
         #TODO: остановился где-то тут, функция не дописана. Хотел сделать админку + бан пользователей
@@ -60,278 +368,13 @@ def telegram_bot():
                 pass
             elif message.text == "Забанить пользователя по ID":
                 bot.send_message(message.chat.id, "Пришли ID юзера")
-                BotDB.set_user_blacklist(ban_user_id)
+                #BotDB.set_user_blacklist(ban_user_id)
-                bot.reply_to(message, f"Пользователь {ban_user_id} заблокирован.")
+                #bot.reply_to(message, f"Пользователь {ban_user_id} заблокирован.")
         except Exception as e:
             bot.reply_to(message, f"Укажи ID пользователя. Ошибка\n\n {e}")
             bot.register_next_step_handler(message, ban_user)
 
 
-
-    @bot.message_handler(commands=['start'])
-    def send_welcome(message):
-        # TODO: Тексты приветствий вынести в отдельный файл
-        try:
-            name_stick_hello = list(Path('Stick').rglob('Hello_*'))
-            number_stick_hello = random.randint(1, len(name_stick_hello))
-            random_stick_hello = open(name_stick_hello[number_stick_hello], 'rb')
-            # logging
-            if LOGS:
-                bot.forward_message(chat_id=GROUP_FOR_LOGS,
-                                    from_chat_id=message.chat.id,
-                                    message_id=message.message_id)
-            bot.send_sticker(message.chat.id, random_stick_hello)
-            sleep(0.3)
-        except Exception as e:
-            if LOGS:
-                bot.send_message(IMPORTANT_LOGS, f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-        try:
-            user_id = message.from_user.id
-            first_name = message.from_user.first_name
-            full_name = message.from_user.full_name
-            is_bot = message.from_user.is_bot
-            username = message.from_user.username
-            language_code = message.from_user.language_code
-            time_utc = int(time.time())
-            date_added = datetime.fromtimestamp(time_utc)
-            date_changed = datetime.fromtimestamp(time_utc)
-
-            markup = types.ReplyKeyboardMarkup(resize_keyboard=True, one_time_keyboard=True)
-            item1 = types.KeyboardButton("📢Предложить свой пост")
-            item2 = types.KeyboardButton("📩Связаться с админами")
-            # TODO: Выпилил, удалить
-            # item3 = types.KeyboardButton("❌Удалить пост")
-            if BotDB.user_exists(user_id):
-                is_need_sticker = BotDB.get_info_about_stickers(user_id=message.from_user.id)
-                if is_need_sticker == 0:
-                    item5 = types.KeyboardButton("🤪Хочу стикеры")
-                    BotDB.update_info_about_stickers(user_id=message.from_user.id)
-                    markup.add(item1, item2, item5)
-                else:
-                    markup.add(item1, item2)
-            else:
-                BotDB.add_new_user_in_db(user_id, first_name, full_name, username, is_bot, language_code, date_added,
-                                         date_changed)
-                is_need_sticker = BotDB.get_info_about_stickers(user_id=message.from_user.id)
-                if is_need_sticker == 0:
-                    item5 = types.KeyboardButton("🤪Хочу стикеры")
-                    BotDB.update_info_about_stickers(user_id=message.from_user.id)
-                    markup.add(item1, item2, item5)
-                else:
-                    markup.add(item1, item2)
-            hello_message = messages.get_message(__get_first_name(message), 'HELLO_MESSAGE')
-            bot.send_message(message.chat.id, hello_message, parse_mode='html', reply_markup=markup,
-                             disable_web_page_preview=not PREVIEW_LINK)
-        except Exception as e:
-            if LOGS:
-                bot.send_message(IMPORTANT_LOGS, f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-        bot.register_next_step_handler(message, go_send_messages)
-
-    @bot.message_handler(commands=['end_command'])
-    def after_post(message):
-        markup = types.ReplyKeyboardMarkup(resize_keyboard=True, one_time_keyboard=True)
-        item1 = types.KeyboardButton("📢Предложить свой пост")
-        item2 = types.KeyboardButton("📩Связаться с админами")
-        # TODO: Скрыл, удалить обработчик
-        # item3 = types.KeyboardButton("❌Удалить пост")
-        item5 = types.KeyboardButton("👋🏼Сказать пока!")
-        markup.add(item1, item2, item5)
-        bot.send_message(message.chat.id,
-                         "Выбери нужную кнопку внизу экрана".format(
-                             message.from_user, bot.get_me()),
-                         parse_mode='html', reply_markup=markup, disable_web_page_preview=not PREVIEW_LINK)
-        bot.register_next_step_handler(message, go_send_messages)
-
-    def go_send_messages(message):
-        global msg
-        if message.text == '📢Предложить свой пост':
-            try:
-                markup = types.ReplyKeyboardRemove()
-                suggest_news = messages.get_message(__get_first_name(message), 'SUGGEST_NEWS')
-                bot.send_message(message.chat.id, suggest_news, parse_mode='html')
-                sleep(0.3)
-                suggest_news_2 = messages.get_message(__get_first_name(message), 'SUGGEST_NEWS_2')
-                msg = bot.send_message(message.chat.id, suggest_news_2, parse_mode='html', reply_markup=markup)
-            except Exception as e:
-                if LOGS:
-                    bot.send_message(IMPORTANT_LOGS,
-                                     f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-                # logging
-            if LOGS:
-                bot.forward_message(chat_id=GROUP_FOR_LOGS,
-                                    from_chat_id=message.chat.id,
-                                    message_id=message.message_id)
-            bot.register_next_step_handler(msg, resend_message_in_group_for_post)
-
-        elif message.text == "📩Связаться с админами":
-            connect_with_admin = messages.get_message(__get_first_name(message), 'CONNECT_WITH_ADMIN')
-            msg = bot.send_message(message.chat.id, connect_with_admin, parse_mode="html")
-            # logging
-            if LOGS:
-                bot.forward_message(chat_id=GROUP_FOR_LOGS,
-                                    from_chat_id=message.chat.id,
-                                    message_id=message.message_id)
-            bot.register_next_step_handler(msg, resend_message_in_group_for_message)
-
-        elif message.text == "❌Удалить пост":
-            # TODO: требует автоматизации. На входе говорим пришли мне пост, на выходе получаем идентификатор поста, удаляем из ТГ. Насчет удаления из ВК надо подумать
-            del_message = messages.get_message(__get_first_name(message), 'DEL_MESSAGE')
-            msg = bot.send_message(message.chat.id, del_message, parse_mode="html")
-            # logging
-            if LOGS:
-                bot.forward_message(chat_id=GROUP_FOR_LOGS,
-                                    from_chat_id=message.chat.id,
-                                    message_id=message.message_id)
-            bot.register_next_step_handler(msg, resend_message_in_group_for_message)
-
-        elif message.text == "👋🏼Сказать пока!":
-            try:
-                name_stick_bye = list(Path('Stick').rglob('Universal_*'))
-                number_stick_bye = random.randint(1, len(name_stick_bye))
-                random_stick_bye = open(name_stick_bye[number_stick_bye], 'rb')
-                bot.send_sticker(message.chat.id, random_stick_bye)
-            except ApiTelegramException as e:
-                if LOGS:
-                    bot.send_message(chat_id=IMPORTANT_LOGS,
-                                     text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-            markup = types.ReplyKeyboardRemove()
-            try:
-                bye_message = messages.get_message(__get_first_name(message), 'BYE_MESSAGE')
-                bot.send_message(message.chat.id, bye_message,
-                                 parse_mode='html', reply_markup=markup, disable_web_page_preview=not PREVIEW_LINK)
-            except Exception as e:
-                if LOGS:
-                    bot.send_message(chat_id=IMPORTANT_LOGS,
-                                     text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-
-            if LOGS:
-                # logging
-                bot.forward_message(chat_id=GROUP_FOR_LOGS,
-                                    from_chat_id=message.chat.id,
-                                    message_id=message.message_id)
-        elif message.text == "🤪Хочу стикеры":
-            markup = types.ReplyKeyboardMarkup(resize_keyboard=True, one_time_keyboard=True)
-            item1 = types.KeyboardButton("📢Предложить свой пост")
-            item2 = types.KeyboardButton("📩Связаться с админами")
-            # TODO: Скрыл кнопку, убрать обработчик позднее
-            # item3 = types.KeyboardButton("❌Удалить пост")
-            item5 = types.KeyboardButton("👋🏼Сказать пока!")
-            markup.add(item1, item2, item5)
-            try:
-                if LOGS:
-                    bot.forward_message(chat_id=GROUP_FOR_LOGS,
-                                        from_chat_id=message.chat.id,
-                                        message_id=message.message_id)
-                bot.send_message(message.chat.id,
-                                 text='Хорошо, лови, добавить можно отсюда: https://t.me/addstickers/love_biysk',
-                                 reply_markup=markup)
-                bot.register_next_step_handler(message, callback=go_send_messages)
-            except ApiTelegramException as e:
-                if LOGS:
-                    bot.send_message(chat_id=IMPORTANT_LOGS,
-                                     text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-        else:
-            try:
-                user_error = messages.get_message(__get_first_name(message), 'USER_ERROR')
-                bot.send_message(message.chat.id, user_error, parse_mode='html',
-                                 disable_web_page_preview=not PREVIEW_LINK)
-            except Exception as e:
-                if LOGS:
-                    bot.send_message(chat_id=IMPORTANT_LOGS,
-                                     text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-            # logging
-            if LOGS:
-                bot.forward_message(chat_id=GROUP_FOR_LOGS,
-                                    from_chat_id=message.chat.id,
-                                    message_id=message.message_id)
-            bot.register_next_step_handler(message, callback=go_send_messages)
-
-    def resend_message_in_group_for_post(message):
-        markup = types.InlineKeyboardMarkup(row_width=1)
-        item1 = types.InlineKeyboardButton("Опубликовать", callback_data='post_post_post')
-        item2 = types.InlineKeyboardButton("Отклонить", callback_data='decline')
-        markup.add(item1, item2)
-        try:
-            if message.content_type == 'text':
-                post_text = message.text.lower()
-                if post_text.find('неанон') != -1 or post_text.find('не анон') != -1:
-                    bot.send_message(
-                        # TODO: GROUP_FOR_POST
-                        chat_id=GROUP_FOR_POST,
-                        text=f'Пост из ТГ:\n{post_text}\n\nАвтор поста: {message.from_user.first_name} @{message.from_user.username}',
-                        reply_markup=markup
-                    )
-                elif post_text.find('анон') != -1:
-                    bot.send_message(
-                        # TODO: GROUP_FOR_POST
-                        chat_id=GROUP_FOR_POST,
-                        text=f'Пост из ТГ:\n{message.text}\n\nПост опубликован анонимно',
-                        reply_markup=markup
-                    )
-                else:
-                    bot.send_message(
-                        # TODO: GROUP_FOR_POST
-                        chat_id=GROUP_FOR_POST,
-                        text=f'Пост из ТГ:\n{post_text}\n\nАвтор поста: {message.from_user.first_name} @{message.from_user.username}',
-                        reply_markup=markup
-                    )
-            elif message.content_type == 'photo' and message.media_group_id is None:
-                post_text_for_photo = message.caption.lower()
-                if post_text_for_photo.find('неанон') != -1 or post_text_for_photo.find('не анон') != -1:
-                    bot.send_photo(
-                        # TODO: GROUP_FOR_POST
-                        chat_id=GROUP_FOR_POST,
-                        caption=f'Пост из ТГ:\n{post_text_for_photo}\n\nАвтор поста: {message.from_user.first_name} @{message.from_user.username}',
-                        photo=message.photo[-1].file_id,
-                        reply_markup=markup
-                    )
-                elif post_text_for_photo.find('анон') != -1 or post_text_for_photo.find('анон') != -1:
-                    bot.send_photo(
-                        # TODO: GROUP_FOR_POST
-                        chat_id=GROUP_FOR_POST,
-                        caption=f'Пост из ТГ:\n{post_text_for_photo}\n\nПост опубликован анонимно',
-                        photo=message.photo[-1].file_id,
-                        reply_markup=markup
-                    )
-                else:
-                    bot.send_photo(
-                        # TODO: GROUP_FOR_POST
-                        chat_id=GROUP_FOR_POST,
-                        caption=f'Пост из ТГ:\n{post_text_for_photo}\n\nАвтор поста: {message.from_user.first_name} @{message.from_user.username}',
-                        photo=message.photo[-1].file_id,
-                        reply_markup=markup
-                    )
-            # TODO: Не понятна реализация с альбомами от слова совсем
-            # elif message.content_type == 'photo' and message.media_group_id != None:
-            #    bot.forward_message(chat_id=IMPORTANT_LOGS, from_chat_id=message.chat.id, message_id=message.message_id )
-            else:
-                pass
-        except Exception as e:
-            if LOGS:
-                bot.send_message(chat_id=IMPORTANT_LOGS,
-                                 text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-
-        success_send_message = messages.get_message(__get_first_name(message), 'SUCCESS_SEND_MESSAGE')
-
-        bot.send_message(message.chat.id, success_send_message, parse_mode='html',
-                         disable_web_page_preview=not PREVIEW_LINK)
-        after_post(message=message)
-
-    def resend_message_in_group_for_message(message):
-        bot.forward_message(chat_id=GROUP_FOR_MESSAGE,
-                            from_chat_id=message.chat.id,
-                            message_id=message.message_id
-                            )
-        question = messages.get_message(__get_first_name(message), 'QUESTION')
-        bot.send_message(message.chat.id, question, parse_mode='html', disable_web_page_preview=not PREVIEW_LINK)
-        try:
-            pass
-        except Exception as e:
-            if LOGS:
-                bot.send_message(chat_id=IMPORTANT_LOGS,
-                                 text=f"Произошла ошибка: {str(e)}\n\nTraceback:\n{traceback.format_exc()}")
-        after_post(message=message)
-
     # Админка
     @bot.callback_query_handler(func=lambda call: True)
     def post_for_group(call):
@@ -367,12 +410,6 @@ def telegram_bot():
         return message.from_user.first_name
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
-    telegram_bot()
+    # Запускаем бота
-    while True:
+    bot.start()
-        try:
-            bot.polling(none_stop=True)
-            bot.enable_save_next_step_handlers(delay=2)
-            bot.load_next_step_handlers()
-        except (ConnectionError, Exception):
-            print(f"Произошла ошибка: {str(Exception)}\n\nTraceback:\n{traceback.format_exc()}")