Code restructurings step 2/5: decompose telegram front-end

Decomposed telegram front-end part, rearranged code, fixed some imports (both in telegram and core parts). The code seems to work now [but it now requires a VERY strange actions to make it run], though it has various shitty parts yet. There are things to decompose further (like the invitations system), and I'm planning to do some cosmetic changes (reorganize files themselves, rename something, reorder imports) after I'm done with the substantive part

Author: kolayne

.gitignore

@@ -235,4 +235,4 @@ dmypy.json
 
 
 # Project-level
-/config.py
+**config**

core/db_connector.py

@@ -3,7 +3,7 @@
 from psycopg2 import connect
 from psycopg2.extensions import cursor as cursor_type
 
-from ..config import db_host, db_name, db_username, db_password
+from .config import db_host, db_name, db_username, db_password
 
 
 @contextmanager

core/invitations.py

@@ -6,8 +6,8 @@
 
 from .users import get_local_id, get_free_operators
 from .conversations import get_conversing
-from telegram_bot.callback_helpers import contract_callback_data_and_jdump
-from telegram_bot.__main__ import bot  # TODO: remove this terrible shit
+from ..telegram_bot.utils.callback_helpers import contract_callback_data_and_jdump
+from ..telegram_bot._bot import bot  # TODO: remove this terrible shit
 
 
 # Whenever a client requests a conversation, all the <b>free</b> operators get a message which invites them to start

telegram_bot/__init__.py

@@ -0,0 +1,7 @@
+from ._bot import bot
+# Create `bot` handlers
+from . import message_handlers as _
+from . import callback_handlers as _
+
+
+__all__ = ["bot"]

telegram_bot/__main__.py

@@ -0,0 +1,6 @@
+import telebot
+
+from .config import bot_token
+
+
+bot = telebot.TeleBot(bot_token)

telegram_bot/_bot.py

@@ -0,0 +1,68 @@
+import telebot
+
+from ..core.conversations import begin_conversation, get_conversing
+from ..core.invitations import conversation_starter_lock, operators_invitations_messages, clear_invitation_messages
+from ._bot import bot
+from .utils import nonfalling_handler, notify_admins
+from .utils.callback_helpers import jload_and_decontract_callback_data, datetime_from_local_epoch_secs
+
+
+def get_type_from_callback_data(call_data):
+    d = jload_and_decontract_callback_data(call_data)
+    if not isinstance(d, dict):
+        return None
+    return d.get('type')
+
+
+# Invalid callback query handler
+@bot.callback_query_handler(func=lambda call: get_type_from_callback_data(call.data) is None)
+@nonfalling_handler
+def invalid_callback_query(call: telebot.types.CallbackQuery):
+    bot.answer_callback_query(call.id, "Действие не поддерживается или некорректные данные обратного вызова")
+
+
+@bot.callback_query_handler(func=lambda call: get_type_from_callback_data(call.data) == 'conversation_rate')
+@nonfalling_handler
+def conversation_rate_callback_query(call: telebot.types.CallbackQuery):
+    d = jload_and_decontract_callback_data(call.data)
+
+    mood = d.get('mood')
+    if mood == 'worse':
+        operator_tg, operator_local = d['operator_ids']
+        conversation_end = datetime_from_local_epoch_secs(d['conversation_end_moment'])
+        notification_text = "Клиент чувствует себя хуже после беседы с оператором {}, которая завершилась в {}".format(
+            f"[{operator_local}](tg://user?id={operator_tg})", conversation_end
+        )
+        notify_admins(text=notification_text, parse_mode="Markdown")
+
+    bot.edit_message_reply_markup(call.message.chat.id, call.message.message_id, reply_markup=None)
+
+    if mood is None:
+        bot.answer_callback_query(call.id)
+    else:
+        bot.answer_callback_query(call.id, "Спасибо за вашу оценку")
+
+
+@bot.callback_query_handler(func=lambda call: get_type_from_callback_data(call.data) == 'conversation_acceptation')
+@nonfalling_handler
+def conversation_acceptation_callback_query(call: telebot.types.CallbackQuery):
+    d = jload_and_decontract_callback_data(call.data)
+    with conversation_starter_lock:
+        if call.message.chat.id in operators_invitations_messages.keys():
+            bot.answer_callback_query(call.id, "Невозможно начать беседу, пока вы ожидаете оператора")
+            return
+
+        conversation_began = begin_conversation(d['client_id'], call.message.chat.id)
+
+    if conversation_began:
+        clear_invitation_messages(d['client_id'])
+
+        (_, local_client_id), (_, local_operator_id) = get_conversing(call.message.chat.id)
+        bot.answer_callback_query(call.id)
+        bot.send_message(call.message.chat.id, f"Началась беседа с клиентом №{local_client_id}. Отправьте "
+                                               "сообщение, и собеседник его увидит")
+        bot.send_message(d['client_id'], f"Началась беседа с оператором №{local_operator_id}. Отправьте сообщение, "
+                                         "и собеседник его увидит")
+    else:
+        bot.answer_callback_query(call.id, "Что-то пошло не так. Возможно, вы уже в беседе, или другой оператор принял "
+                                           "это приглашение")

telegram_bot/callback_handlers.py

@@ -0,0 +1,128 @@
+from datetime import datetime
+
+import telebot
+
+from ..core.conversations import get_conversing, end_conversation
+from ..core.db_connector import PrettyCursor
+from ..core.invitations import invite_operators, clear_invitation_messages
+from ..core.users import add_user
+from ._bot import bot
+from .utils import nonfalling_handler, AnyContentType
+from .utils.callback_helpers import seconds_since_local_epoch, contract_callback_data_and_jdump
+
+
+@bot.message_handler(commands=['start', 'help'])
+@nonfalling_handler
+def start_help_handler(message: telebot.types.Message):
+    bot.reply_to(message, "Привет. /request_conversation, чтобы начать беседу, /end_conversation чтобы завершить")
+    add_user(message.chat.id)
+
+
+@bot.message_handler(commands=['request_conversation'])
+@nonfalling_handler
+def request_conversation_handler(message: telebot.types.Message):
+    (tg_client_id, _), (tg_operator_id, _) = get_conversing(message.chat.id)
+    if tg_operator_id == message.chat.id:
+        bot.reply_to(message, "Операторы не могут запрашивать помощь, пока помогают кому-то")
+    elif tg_client_id == message.chat.id:
+        bot.reply_to(message, "Вы уже в беседе с оператором. Используйте /end_conversation чтобы прекратить")
+    else:
+        result = invite_operators(message.chat.id)
+        if result == 0:
+            bot.reply_to(message, "Операторы получили запрос на присоединение. Ждем оператора...\nИспользуйте "
+                                  "/end_conversation, чтобы отменить запрос")
+        elif result == 1:
+            bot.reply_to(message, "Вы уже ожидаете присоединения оператора. Используйте /end_conversation, чтобы "
+                                  "отказаться от беседы")
+        elif result == 2:
+            bot.reply_to(message, "Сейчас нет свободных операторов. Пожалуйста, попробуйте позже")
+        elif result == 3:
+            bot.reply_to(message, "Вы уже в беседе. Используйте /end_conversation, чтобы выйти из нее")
+        else:
+            raise NotImplementedError("`invite_operators` returned an unexpected value")
+
+
+@bot.message_handler(commands=['end_conversation'])
+@nonfalling_handler
+def end_conversation_handler(message: telebot.types.Message):
+    (_, client_local), (operator_tg, operator_local) = get_conversing(message.chat.id)
+
+    if operator_tg is None:
+        if clear_invitation_messages(message.chat.id):
+            bot.reply_to(message, "Ожидание операторов отменено. Используйте /request_conversation, чтобы запросить "
+                                  "помощь снова")
+        else:
+            bot.reply_to(message, "В данный момент вы ни с кем не беседуете. Используйте /request_conversation, чтобы "
+                                  "начать")
+    elif operator_tg == message.chat.id:
+        bot.reply_to(message, "Оператор не может прекратить беседу. Обратитесь к @kolayne для реализации такой "
+                              "возможности")
+    else:
+        keyboard = telebot.types.InlineKeyboardMarkup()
+        d = {'type': 'conversation_rate', 'operator_ids': [operator_tg, operator_local],
+             'conversation_end_moment': seconds_since_local_epoch(datetime.now())}
+
+        keyboard.add(
+            telebot.types.InlineKeyboardButton("Лучше",
+                                               callback_data=contract_callback_data_and_jdump({**d, 'mood': 'better'})),
+            telebot.types.InlineKeyboardButton("Так же",
+                                               callback_data=contract_callback_data_and_jdump({**d, 'mood': 'same'})),
+            telebot.types.InlineKeyboardButton("Хуже",
+                                               callback_data=contract_callback_data_and_jdump({**d, 'mood': 'worse'}))
+        )
+        keyboard.add(telebot.types.InlineKeyboardButton("Не хочу оценивать",
+                                                        callback_data=contract_callback_data_and_jdump(d)))
+
+        end_conversation(message.chat.id)
+        bot.reply_to(message, "Беседа с оператором прекратилась. Хотите оценить свое самочувствие после нее? "
+                              "Вы остаетесь анонимным", reply_markup=keyboard)
+        bot.send_message(operator_tg, f"Пользователь №{client_local} прекратил беседу")
+
+
+@bot.message_handler(content_types=['text'])
+@nonfalling_handler
+def text_message_handler(message: telebot.types.Message):
+    (client_tg, _), (operator_tg, _) = get_conversing(message.chat.id)
+
+    if client_tg is None:
+        bot.reply_to(message, "Чтобы начать общаться с оператором, нужно написать /request_conversation. Сейчас у вас "
+                              "нет собеседника")
+        return
+
+    interlocutor_id = client_tg if message.chat.id != client_tg else operator_tg
+
+    reply_to = None
+    if message.reply_to_message is not None:
+        with PrettyCursor() as cursor:
+            cursor.execute("SELECT sender_message_id FROM reflected_messages WHERE sender_chat_id=%s AND "
+                           "receiver_chat_id=%s AND receiver_message_id=%s",
+                           (interlocutor_id, message.chat.id, message.reply_to_message.message_id))
+            try:
+                reply_to, = cursor.fetchone()
+            except TypeError:
+                bot.reply_to(message, "Эта беседа уже завершилась. Вы не можете ответить на это сообщение")
+                return
+
+    for entity in message.entities or []:
+        if entity.type in ('mention', 'bot_command'):
+            continue
+        if entity.type == 'url' and message.text[entity.offset: entity.offset + entity.length] == entity.url:
+            continue
+
+        bot.reply_to(message, "Это сообщение содержит форматирование, которое сейчас не поддерживается. Оно будет "
+                              "отправлено с потерей форматирования. Мы работаем над этим")
+        break
+
+    sent = bot.send_message(interlocutor_id, message.text, reply_to_message_id=reply_to)
+
+    with PrettyCursor() as cursor:
+        query = "INSERT INTO reflected_messages(sender_chat_id, sender_message_id, receiver_chat_id, " \
+                "receiver_message_id) VALUES (%s, %s, %s, %s)"
+        cursor.execute(query, (message.chat.id, message.message_id, sent.chat.id, sent.message_id))
+        cursor.execute(query, (sent.chat.id, sent.message_id, message.chat.id, message.message_id))
+
+
+@bot.message_handler(content_types=AnyContentType())
+@nonfalling_handler
+def another_content_type_handler(message: telebot.types.Message):
+    bot.reply_to(message, "Сообщения этого типа не поддерживаются. Свяжитесь с @kolayne, чтобы добавить поддержку")

telegram_bot/message_handlers.py

@@ -0,0 +1,2 @@
+from . import callback_helpers
+from .misc import *

telegram_bot/utils/__init__.py

@@ -0,0 +1,75 @@
+from functools import wraps
+from sys import stderr
+from traceback import format_exc
+from typing import Callable
+
+import telebot
+
+from ...core.users import get_admins_ids
+from .._bot import bot  # TODO: remove this terrible shit
+
+
+def notify_admins(**kwargs) -> bool:
+    """
+    Send a text message to all the bot administrators. Any exceptions occurring inside are suppressed
+
+    ::param kwargs: Keyword arguments to be forwarded to `bot.send_message` (shouldn't contain `chat_id`)
+    :return: `True` if a message was successfully delivered to at least one admin (i. e. no exception occurred), `False`
+        otherwise
+    """
+    try:
+        admins = get_admins_ids()
+    except Exception:
+        print("Couldn't get admins ids inside of `notify_admins`:", file=stderr)
+        print(format_exc(), file=stderr)
+        return False
+
+    sent = False
+
+    try:
+        for i in admins:
+            try:
+                bot.send_message(chat_id=i, **kwargs)
+            except Exception:
+                print("Couldn't send a message to an admin inside of `notify_admins`:", file=stderr)
+                print(format_exc(), file=stderr)
+            else:
+                sent = True
+
+    except Exception:
+        print("Something went wrong while **iterating** throw `admins` inside of `notify_admins`:", file=stderr)
+        print(format_exc(), file=stderr)
+
+    return sent
+
+
+def nonfalling_handler(func: Callable):
+    @wraps(func)
+    def ans(message: telebot.types.Message, *args, **kwargs):
+        try:
+            func(message, *args, **kwargs)
+        except Exception:
+            try:
+                # For callback query handlers
+                # (we got a `telebot.types.CallbackQuery` object instead of a `telebot.types.Message` object)
+                if hasattr(message, 'message'):
+                    message = message.message
+
+                s = "Произошла ошибка"
+                if notify_admins(text=('```' + format_exc() + '```'), parse_mode="Markdown"):
+                    s += ". Наши администраторы получили уведомление о ней"
+                else:
+                    s += ". Свяжитесь с администрацией бота для исправления"
+                s += ". Технические детали:\n```" + format_exc() + "```"
+
+                print(format_exc(), file=stderr)
+                bot.send_message(message.chat.id, s, parse_mode="Markdown")
+            except Exception:
+                print("An exception while handling an exception:", file=stderr)
+                print(format_exc(), file=stderr)
+
+    return ans
+
+
+class AnyContentType:
+    def __contains__(self, item): return True