def message_handler(update: Update, context: CallbackContext):
intent, reply = get_reply(update.to_dict()['message']['text'], update.to_dict()[
'message']['chat']['id'])
if intent == "get_news":
articles = fetch_news(reply)
for article in articles:
update.message.reply_text(article['link'])
else:
update.message.reply_text(reply)
def reply(update: telegram.Update, context: telegram.ext.CallbackContext):
print(update.to_dict())
msg = update.effective_message
from_user, rpl_user = get_users(msg)
command = parse_command(context.match)
if from_user == rpl_user:
mention_match = mentionParser.search(command['predicate'])
if mention_match:
mention = mentionParser.search(msg.text).group(1)
rpl_user = User(username=mention)
command['predicate'] = command['predicate'][:mention_match.start()]
else:
mention_match = mentionParser.search(command['complement'])
if mention_match:
mention = mentionParser.search(msg.text).group(1)
rpl_user = User(username=mention)
complement = command['complement']
complement = complement[:mention_match.start()] + complement[mention_match.end():]
command['complement'] = complement.strip()
if command['swap'] and (not from_user == rpl_user):
(from_user, rpl_user) = (rpl_user, from_user)
text = get_text(from_user, rpl_user, command)
print(text, end='\n\n')
update.effective_message.reply_text(text, parse_mode='HTML')
def error_handler(update: Update, context: CallbackContext):
"""Log the error and send a telegram message to notify the developer."""
# Log the error before we do anything else, so we can see it even if something breaks.
logger.error(msg="Exception while handling an update:",
exc_info=context.error)
# traceback.format_exception returns the usual python message about an exception, but as a
# list of strings rather than a single string, so we have to join them together.
tb_list = traceback.format_exception(None, context.error,
context.error.__traceback__)
tb = ''.join(tb_list)
message = ('An exception was raised while handling an update\n'
'<pre>update = {}</pre>\n\n'
'<pre>context.chat_data = {}</pre>\n\n'
'<pre>context.user_data = {}</pre>\n\n'
'<pre>{}</pre>').format(
html.escape(
json.dumps(update.to_dict(),
indent=2,
ensure_ascii=False)),
html.escape(str(context.chat_data)),
html.escape(str(context.user_data)),
html.escape(tb),
)
# Finally, send the message
context.bot.send_message(chat_id=config["Texte"]["Developer"],
text=message,
parse_mode=ParseMode.HTML)
def process_comment_reply(update: Update):
if not update.message.reply_to_message:
return
user = get_bot_user(update)
if not user:
return
comment_url_entity = [
entity["url"] for entity in update.message.reply_to_message.entities if
entity["type"] == "text_link" and COMMENT_URL_RE.match(entity["url"])
]
if not comment_url_entity:
log.info(
f"Comment url not found in: {update.message.reply_to_message.entities}"
)
return
comment_id = COMMENT_URL_RE.match(comment_url_entity[0]).group(1)
comment = Comment.objects.filter(id=comment_id).first()
if not comment:
log.info(f"Comment not found: {comment_id}")
return
is_ok = Comment.check_rate_limits(user)
if not is_ok:
send_telegram_message(
chat=Chat(id=update.effective_chat.id),
text=
f"🙅♂️ Извините, вы комментировали слишком часто и достигли дневного лимита"
)
return
text = update.message.text or update.message.caption
if not text:
send_telegram_message(
chat=Chat(id=update.effective_chat.id),
text=f"😣 Сорян, я пока умею только в текстовые ответы")
return
# max 3 levels of comments are allowed
reply_to_id = comment.id
if comment.reply_to_id and comment.reply_to.reply_to_id:
reply_to_id = comment.reply_to_id
reply = Comment.objects.create(author=user,
post=comment.post,
reply_to_id=reply_to_id,
text=f"@{comment.author.slug}, {text}",
useragent="TelegramBot (like TwitterBot)",
metadata={"telegram": update.to_dict()})
new_comment_url = settings.APP_HOST + reverse("show_comment",
kwargs={
"post_slug":
reply.post.slug,
"comment_id": reply.id
})
send_telegram_message(
chat=Chat(id=update.effective_chat.id),
text=f"➜ <a href=\"{new_comment_url}\">Отвечено</a> 👍")
def error_handler(update: Update, context: CallbackContext):
"""Log the error and send a telegram message to notify the developer."""
conf.logger.error(msg="Exception while handling an update: ",
exc_info=context.error)
# traceback.format_exception returns the usual python message about an exception, but as a
# list of strings rather than a single string, so we have to join them together.
tb_list = traceback.format_exception(
None, context.error, context.error.__traceback__)
tb = ''.join(tb_list)
message = (
'An exception was raised while handling an update\n'
'<pre>update = {}</pre>\n\n'
'<pre>context.chat_data = {}</pre>\n\n'
'<pre>context.user_data = {}</pre>\n\n'
'<pre>{}</pre>'
).format(
html.escape(json.dumps(update.to_dict(),
indent=2, ensure_ascii=False)),
html.escape(str(context.chat_data)),
html.escape(str(context.user_data)),
html.escape(tb),
)
DEVELOPER_CHAT_ID = os.getenv('DEVELOPER_CHAT_ID')
context.bot.send_message(chat_id=DEVELOPER_CHAT_ID,
text=message[:4096])
return ConversationHandler.END
def inspect_update(update: Update, context: CallbackContext):
for chunk in chunks(json.dumps(update.to_dict(), indent=2), 4000):
context.bot.send_message(constants.RENYHP, "<code>" + chunk + "</code>", ParseMode.HTML)
try:
context.bot.send_message(constants.RENYHP, "text:\n" + update.effective_message.text)
except:
pass
def error_handler(update: Update, context: CallbackContext) -> None:
"""Log the error and send a telegram message to notify the developer."""
# Log the error before we do anything else, so we can see it even if something breaks.
logger.error(msg="Exception while handling an update:",
exc_info=context.error)
# traceback.format_exception returns the usual python message about an exception, but as a
# list of strings rather than a single string, so we have to join them together.
tb_list = traceback.format_exception(None, context.error,
context.error.__traceback__)
tb_string = ''.join(tb_list)
# Build the message with some markup and additional information about what happened.
# You might need to add some logic to deal with messages longer than the 4096 character limit.
message = ('An exception was raised while handling an update\n'
'<pre>update = {}</pre>\n\n'
'<pre>context.chat_data = {}</pre>\n\n'
'<pre>context.user_data = {}</pre>\n\n'
'<pre>{}</pre>').format(
html.escape(
json.dumps(update.to_dict(),
indent=2,
ensure_ascii=False)),
html.escape(str(context.chat_data)),
html.escape(str(context.user_data)),
html.escape(tb_string),
)
# Finally, send the message
context.bot.send_message(chat_id=DEVELOPER_CHAT_ID,
text=message,
parse_mode=ParseMode.HTML)
def error_handler(update: Update, context: CallbackContext) -> None:
"""Log the error and send a telegram message to notify the developer."""
# Log the error before we do anything else, so we can see it even if something breaks.
logger.error(msg="Exception while handling an update:", exc_info=context.error)
# traceback.format_exception returns the usual python message about an exception, but as a
# list of strings rather than a single string, so we have to join them together.
tb_list = traceback.format_exception(None, context.error, context.error.__traceback__)
tb_string = ''.join(tb_list)
# Build the message with some markup and additional information about what happened.
# You might need to add some logic to deal with messages longer than the 4096 character limit.
update_str = update.to_dict() if isinstance(update, Update) else str(update)
message = (
f'An exception was raised while handling an update\n'
f'<pre>update = {html.escape(json.dumps(update_str, indent=2, ensure_ascii=False))}'
'</pre>\n\n'
f'<pre>context.chat_data = {html.escape(str(context.chat_data))}</pre>\n\n'
f'<pre>context.user_data = {html.escape(str(context.user_data))}</pre>\n\n'
f'<pre>{html.escape(tb_string)}</pre>'
)
# user = User.get_or_none(username=config('username'))
# if user and user.chat_id:
# # Finally, send the message
context.bot.send_message(chat_id= update.effective_chat.id, text=message, parse_mode='HTML')
def new_func(bot: Bot, update: Update):
# noinspection PyBroadException
try:
return func(bot, update)
except Exception:
logger.error(f"Critical error: {sys.exc_info()}")
# noinspection PyBroadException
try:
bot.send_message(
int(config["Telegram"]["main_group"]),
"☢ **ERRORE CRITICO!** \n"
f"Il bot ha ignorato il comando.\n"
f"Una segnalazione di errore è stata automaticamente mandata a @Steffo.\n\n"
f"Dettagli dell'errore:\n"
f"```\n"
f"{sys.exc_info()}\n"
f"```",
parse_mode="Markdown")
except Exception:
logger.error(f"Double critical error: {sys.exc_info()}")
if not __debug__:
sentry.user_context({
"id": update.effective_user.id,
"telegram": {
"username": update.effective_user.username,
"first_name": update.effective_user.first_name,
"last_name": update.effective_user.last_name
}
})
sentry.extra_context({"update": update.to_dict()})
sentry.captureException()
def error_handler(update: Update, context: CallbackContext) -> None:
logger.error(msg="Exception occurred while handling an update:",
exc_info=context.error)
tb_str = ''.join(
traceback.format_exception(None, context.error,
context.error.__traceback__))
update_str = update.to_dict() if isinstance(update,
Update) else str(update)
msg = (
f'An exception was raised while handling an update\n'
f'<pre>update = {html.escape(json.dumps(update_str, indent=2, ensure_ascii=False))}'
'</pre>\n\n'
f'<pre>context.chat_data = {html.escape(str(context.chat_data))}</pre>\n\n'
f'<pre>context.user_data = {html.escape(str(context.user_data))}</pre>\n\n'
f'<pre>{html.escape(tb_str)}</pre>')
# os.getenv('username') # Windows
msg = msg.replace(os.getlogin(), "USERNAME")
msg = msg.replace(os.getcwd(), ".")
if len(msg) > 4000:
print('Sending Error!')
piece_len = len(msg) // 4000
msgs = [msg[4000 * i:4000 * (i + 1)]
for i in range(0, piece_len)] + [msg[piece_len * 4000:]]
for index, i_msg in enumerate(msgs):
context.bot.send_message(chat_id=channel_token,
text=f'Page {index}/{len(msgs) - 1}\n\n' +
i_msg,
parse_mode='HTML')
else:
context.bot.send_message(chat_id=channel_token,
text=msg,
parse_mode='HTML')
def command_handle(bot: Bot, update: Update):
"""
Handles commands
"""
_ = lambda x: core.locale.get_localized(x, update.message.chat.id)
LOGGER.debug("Handling command")
if update.message.reply_to_message and update.message.reply_to_message.photo:
update.message.reply_to_message.text = update.message.reply_to_message.caption
modloader_response = MODLOADER.handle_command(update)
LOGGER.debug(modloader_response)
if modloader_response:
bot.send_chat_action(update.message.chat.id, "typing")
user = update.message.from_user
args = update.message.text.split(" ")[1:]
try:
reply = modloader_response(bot, update, user, args)
except Exception:
errmsg = _(MODLOADER.locales["error_occured_please_report"]
) % settings.CHAT_LINK
if settings.USE_SENTRY:
errmsg += _(
MODLOADER.locales["sentry_code"]
) % sentry_support.catch_exc(
extra_context=update.to_dict(),
user_context=update.message.from_user.to_dict())
else:
bot.sendMessage(
settings.ADMIN,
"Error occured in update:" +
"\n<code>%s</code>\n" % html.escape(str(update)) +
"Traceback:" +
"\n<code>%s</code>" % html.escape(traceback.format_exc()),
parse_mode='HTML')
reply = core.message(errmsg, parse_mode="HTML", failed=True)
return send_message(bot, update, reply)
def new_func(bot: telegram.Bot, update: telegram.Update):
# noinspection PyBroadException
try:
bot.send_chat_action(update.message.chat.id, telegram.ChatAction.TYPING)
return func(bot, update)
except TimedOut:
logger.warning(f"Telegram timed out in {update}")
except Exception:
logger.error(f"Critical error: {sys.exc_info()}")
# noinspection PyBroadException
try:
reply_msg(bot, main_group_id, strings.TELEGRAM.ERRORS.CRITICAL_ERROR,
exc_info=repr(sys.exc_info()))
except Exception:
logger.error(f"Double critical error: {sys.exc_info()}")
sentry.user_context({
"id": update.effective_user.id,
"telegram": {
"username": update.effective_user.username,
"first_name": update.effective_user.first_name,
"last_name": update.effective_user.last_name
}
})
sentry.extra_context({
"update": update.to_dict()
})
sentry.captureException()
def wrapper(update: Update, *args, **kwargs):
u = User.update_or_create_from_update(update)
if u:
u.save()
update_dict = remove_empty_from_dict(update.to_dict())
update_dict['method'] = f.__name__
logger.info(f"{update_dict}")
return f(update, *args, **kwargs)
def start(bot: telegram.Bot, update: telegram.Update):
if update.message.chat_id > 0:
keyboard = telegram.ReplyKeyboardMarkup(DEFAULT_KEYBOARD,
one_time_keyboard=False)
bot.sendMessage(update.message.chat_id, start_message,
reply_markup=keyboard)
else:
bot.sendMessage(update.message.chat_id, start_message)
x = authenticate()
x(lambda bot2, update2: print('authenticated:\n' + str(update.to_dict(
))))(bot, update)
Updates.get_updates().botan.track(update.message, 'start')
def process_comment_reply(update: Update):
if not update.message.reply_to_message:
return
user = User.objects.filter(telegram_id=update.effective_user.id).first()
if not user:
send_telegram_message(
chat=Chat(id=update.effective_user.id),
text=f"😐 Извините, мы не знакомы. Привяжите свой аккаунт в профиле на https://vas3k.club"
)
return
comment_url_entity = [
entity["url"] for entity in update.message.reply_to_message.entities
if entity["type"] == "text_link" and COMMENT_URL_RE.match(entity["url"])
]
if not comment_url_entity:
log.info(f"Comment url not found in: {update.message.reply_to_message.entities}")
return
reply_to_id = COMMENT_URL_RE.match(comment_url_entity[0]).group(1)
reply = Comment.objects.filter(id=reply_to_id).first()
if not reply:
log.info(f"Reply not found: {reply_to_id}")
return
is_ok = Comment.check_rate_limits(user)
if not is_ok:
send_telegram_message(
chat=Chat(id=update.effective_chat.id),
text=f"🙅♂️ Извините, вы комментировали слишком часто и достигли дневного лимита"
)
return
comment = Comment.objects.create(
author=user,
post=reply.post,
reply_to=Comment.find_top_comment(reply),
text=update.message.text,
useragent="TelegramBot (like TwitterBot)",
metadata={
"telegram": update.to_dict()
}
)
new_comment_url = settings.APP_HOST + reverse("show_comment", kwargs={
"post_slug": comment.post.slug,
"comment_id": comment.id
})
send_telegram_message(
chat=Chat(id=update.effective_chat.id),
text=f"➜ [Отвечено]({new_comment_url}) 👍"
)
def show_file_id(update: Update, context) -> None:
""" Returns file_id of the attached file/media """
u = User.get_user(update, context)
if u.is_admin:
update_json = update.to_dict()
file_id = _get_file_id(update_json["message"])
message_id = update_json["message"]["message_id"]
update.message.reply_text(
text=f"`{file_id}`",
parse_mode=telegram.ParseMode.HTML,
reply_to_message_id=message_id
)
def comment_to_post(update: Update, context: CallbackContext) -> None:
user = get_club_user(update)
if not user:
return None
post = get_club_post(update)
if not post or post.type in [Post.TYPE_BATTLE, Post.TYPE_WEEKLY_DIGEST]:
return None
is_ok = Comment.check_rate_limits(user)
if not is_ok:
update.message.reply_text(
f"🙅♂️ Извините, вы комментировали слишком часто и достигли дневного лимита"
)
return None
text = update.message.text or update.message.caption
if not text:
update.message.reply_text(
f"😣 Сорян, я пока умею только в текстовые реплаи"
)
return None
if len(text) < MIN_COMMENT_LEN:
update.message.reply_text(
f"😋 Твой коммент слишком короткий. Не буду постить его в Клуб, пускай остается в чате"
)
return None
reply = Comment.objects.create(
author=user,
post=post,
text=text,
useragent="TelegramBot (like TwitterBot)",
metadata={
"telegram": update.to_dict()
}
)
LinkedPost.create_links_from_text(post, text)
new_comment_url = settings.APP_HOST + reverse("show_comment", kwargs={
"post_slug": reply.post.slug,
"comment_id": reply.id
})
update.message.reply_text(
f"➜ <a href=\"{new_comment_url}\">Отвечено</a> 👍",
parse_mode=ParseMode.HTML,
disable_web_page_preview=True
)
def reply_to_comment(update: Update, context: CallbackContext) -> None:
user = get_club_user(update)
if not user:
return None
comment = get_club_comment(update)
if not comment:
return None
is_ok = Comment.check_rate_limits(user)
if not is_ok:
update.message.reply_text(
f"🙅♂️ Извините, вы комментировали слишком часто и достигли дневного лимита"
)
return None
text = update.message.text or update.message.caption
if not text:
update.message.reply_text(
f"😣 Сорян, я пока умею только в текстовые реплаи"
)
return None
# max 3 levels of comments are allowed
reply_to_id = comment.id
if comment.reply_to_id and comment.reply_to.reply_to_id:
reply_to_id = comment.reply_to_id
reply = Comment.objects.create(
author=user,
post=comment.post,
reply_to_id=reply_to_id,
text=f"@{comment.author.slug}, {text}",
useragent="TelegramBot (like TwitterBot)",
metadata={
"telegram": update.to_dict()
}
)
new_comment_url = settings.APP_HOST + reverse("show_comment", kwargs={
"post_slug": reply.post.slug,
"comment_id": reply.id
})
update.message.reply_text(
f"➜ <a href=\"{new_comment_url}\">Отвечено</a> 👍",
parse_mode=ParseMode.HTML,
disable_web_page_preview=True
)
def command(update: Update, context: CallbackContext):
log.debug('Repost channel message')
if log.getEffectiveLevel() == logging.DEBUG:
log.debug('Message:\n%s', json.dumps(update.to_dict(), indent=4))
# log.debug('Context:\n%s', json.dumps(json.loads(str(context)), indent=4))
client = Client()
resp = client.wall_post(message=update.effective_message)
if resp is None:
level = 'error'
text = f""""Message not reposted:
```
{update.effective_message.text}
{update.effective_message.caption}
```
```
{resp}
```
"""
if not client.is_configured:
text += '\n\nVK connection not configured. Send /config to configure it.'
else:
level = ''
text = f"""Message is reposted:
```
{update.effective_message.text}
{update.effective_message.caption}
```
Response:
```
{json.dumps(resp, indent=4)}
```
"""
log_message(text, level)
def error_handler(update: Update, context: CallbackContext) -> None:
"""Log the error and send a telegram message to notify the developer."""
# Log the error before we do anything else, so we can see it even if something breaks.
# logger.error(msg="Exception while handling an update:", exc_info=context.error)
# traceback.format_exception returns the usual python message about an exception, but as a
# list of strings rather than a single string, so we have to join them together.
tb_list = traceback.format_exception(context.error.__class__,
context.error,
context.error.__traceback__)
tb_string = ''.join(tb_list)
# Build the message with some markup and additional information about what happened.
# You might need to add some logic to deal with messages longer than the 4096 character limit.
update_str = update.to_dict() if isinstance(update,
Update) else str(update)
user_data = {}
try:
user_data = User.get(update.effective_user.id).tech_data()
except:
pass
import sentry_sdk
with sentry_sdk.push_scope() as scope:
scope.set_user(user_data)
scope.set_extra('chat', context.chat_data)
scope.set_extra('update', update_str)
sentry_sdk.capture_exception(context.error)
message = (
f'An exception was raised while handling an update\n'
f'<pre>update = {html.escape(json.dumps(update_str, indent=2, ensure_ascii=False))}'
'</pre>\n\n'
f'<pre>context.chat_data = {html.escape(str(context.chat_data))}</pre>\n\n'
f'<pre>context.user_data = {html.escape(str(user_data or ""))}</pre>\n\n'
f'<pre>{html.escape(tb_string)}</pre>')
for admin in User.gods():
context.bot.send_message(chat_id=admin.id,
text=message,
parse_mode=ParseMode.HTML)
def error_handler(update: Update, context: CallbackContext):
"""Log the error and send a telegram message to notify the developer."""
logger.error(msg="Exception while handling an update:",
exc_info=context.error)
tb_list = traceback.format_exception(None, context.error,
context.error.__traceback__)
tb = ''.join(tb_list)
message = ('An exception was raised while handling an update\n'
'<pre>update = {}</pre>\n\n'
'<pre>context.chat_data = {}</pre>\n\n'
'<pre>context.user_data = {}</pre>\n\n'
'<pre>{}</pre>').format(
html.escape(
json.dumps(update.to_dict(),
indent=2,
ensure_ascii=False)),
html.escape(str(context.chat_data)),
html.escape(str(context.user_data)), html.escape(tb))
context.bot.send_message(chat_id=DEV_CHAT_ID,
text=message,
parse_mode=ParseMode.HTML)
def error_handler(update: Update,
context: CallbackContext,
error_message: Union[bool, str] = None) -> None:
"""Log the error and send a telegram message to notify the developer."""
handling_type = 'an update' if update else 'a job from queue'
# Log the error before we do anything else, so we can see it even if something breaks
if context.error:
logger.error(msg=f'Exception while handling {handling_type}:',
exc_info=context.error)
if not error_message:
# traceback.format_exception returns the usual python message about an exception, but as a
# list of strings rather than a single string, so we have to join them together.
tb_list = traceback.format_exception(None, context.error,
context.error.__traceback__)
tb_string = ''.join(tb_list)
additional_info = html.escape(tb_string)
error_type = 'exception'
else:
additional_info = error_message
error_type = 'error'
# Build the message with some markup and additional information about what happened.
# You might need to add some logic to deal with messages longer than the 4096 character limit.
update_dict = update.to_dict() if isinstance(update, Update) else None
bot_data = context.bot_data if update else context.dispatcher.bot_data
chat_data = context.chat_data if update else context.dispatcher.chat_data
user_data = context.user_data if update else context.dispatcher.user_data
message = (
f'An {error_type} was raised while handling {handling_type}.\n\n'
f'update = {html.escape(formatter_to_json(update_dict))}\n\n'
f'context.bot_data = {html.escape(formatter_to_json(bot_data))}\n\n'
f'context.chat_data = {html.escape(formatter_to_json(chat_data))}\n\n'
f'context.user_data = {html.escape(formatter_to_json(user_data))}\n\n'
f'{additional_info}')
# Finally, send the message
log_message_handler(context, message)
def write_to_owner(update: Update):
if OWNER_ID is not None:
message = "Exception threw located:\nUpdate:\n```" + update.to_dict().__str__() + "```\n" + \
"Traceback:\n```" + traceback.format_exc() + "```"
dispatcher.bot.send_message(OWNER_ID, message, parse_mode="Markdown")
def wrapper(update: Update, context: CallbackContext):
# The user has been banned and already got a message regarding this issue
if context.user_data.get("banned-message-sent"):
return
user = None
session = get_session()
try:
if hasattr(update, "message") and update.message:
message = update.message
elif hasattr(update, "edited_message") and update.edited_message:
message = update.edited_message
user, _ = get_user(session, message.from_user)
# Send a message explaining the user, why they cannot use the bot.
# Also set a flag, which prevents sending this messages multiple times and thereby prevents DOS attacks.
if user.banned:
if not context.user_data.get("banned-message-sent"):
context.user_data["banned-message-sent"] = True
message.chat.send_message(
"You have been permanently banned from using this bot, either due to spamming or inappropriate behavior."
"Please refrain from asking questions in the support group or on Github. There's nothing we can do about this."
)
return
# Show an error message, if the users uses the bot in a public chat,
# when he shouldn't. Also check if we're even allowed to send a message.
if private and message.chat.type != "private":
chat = context.bot.getChat(message.chat.id)
if chat.permissions.can_send_messages:
message.chat.send_message(
"Please do this in a direct conversation with me."
)
return
response = func(context.bot, update, session, user)
session.commit()
# Respond to user
if response is not None:
message.chat.send_message(response)
except RollbackException as e:
session.rollback()
message.chat.send_message(
e.message, parse_mode="markdown", disable_web_page_preview=True,
)
except Exception as e:
if not ignore_exception(e):
if config["logging"]["debug"]:
traceback.print_exc()
sentry.capture_exception(
tags={"handler": "message",},
extra={"update": update.to_dict(), "function": func.__name__},
)
locale = "English"
if user is not None:
locale = user.locale
message.chat.send_message(
i18n.t("misc.error", locale=locale),
parse_mode="markdown",
disable_web_page_preview=True,
)
finally:
# The session might not be there yet
# We're checking for bans inside this try/catch, which has to
# happen before session initialization due to performance reasons
if "session" in locals():
session.close()
def message_handler(update: Update, context: CallbackContext):
text = update.to_dict()['message']['text']
update.message.reply_text(text)
def wrapper(update: Update, context: CallbackContext):
user = None
session = get_session()
try:
if hasattr(update, "message") and update.message:
message = update.message
elif hasattr(update,
"edited_message") and update.edited_message:
message = update.edited_message
else:
with configure_scope() as scope:
scope.set_extra("calling_function", func.__name__)
scope.set_extra("update", update.to_dict())
sentry.capture_message(
"Got an update without a message")
return
user, _ = get_user(session, message.from_user)
if user.banned:
return
if private and message.chat.type != "private":
message.chat.send_message(
"Please do this in a direct conversation with me.")
return
response = func(context.bot, update, session, user)
session.commit()
# Respond to user
if response is not None:
message.chat.send_message(response)
except RollbackException as e:
session.rollback()
message.chat.send_message(
e.message,
parse_mode="markdown",
disable_web_page_preview=True,
)
except Exception as e:
if not ignore_exception(e):
if config["logging"]["debug"]:
traceback.print_exc()
with configure_scope() as scope:
scope.set_tag("handler", "message")
sentry.capture_exception()
locale = "English"
if user is not None:
locale = user.locale
message.chat.send_message(
i18n.t("misc.error", locale=locale),
parse_mode="markdown",
disable_web_page_preview=True,
)
finally:
session.close()
def start(update: Update, context: CallbackContext):
fname = update.to_dict()['message']['chat']['first_name']
reply = "Hi! {}".format(fname)
update.message.reply_text(reply)
def news(update: Update, context: CallbackContext):
bot.send_message(chat_id=update.to_dict()[
'message']['chat']['id'], text="Choose a category", reply_markup=ReplyKeyboardMarkup(keyboard=topics_keyboard, one_time_keyboard=True))
def greeting(update: Update, context: CallbackContext):
first_name = update.to_dict()['message']['chat']['first_name']
update.message.reply_text("Hi {}".format(first_name))
def __init__(self, update: telegram.Update, bot):
self.locale = "en"
self.bot = bot
self.update = update
self.locale = octobot.localization.get_chat_locale(self.update)
self.user = update.effective_user
if self.user is not None:
self.user_db = Database[self.user.id]
else:
self.user_db = None
self.chat = update.effective_chat
if self.chat is None and self.user is not None:
self.chat = self.user
self.chat_db = Database[self.chat.id]
self.kbd_id = None
if update.inline_query:
self.text = update.inline_query.query
self.update_type = UpdateType.inline_query
elif update.callback_query:
self.kbd_id = update.callback_query.data.split(":")[0]
self.text = decode_inline(update.callback_query.data)
self.update_type = UpdateType.button_press
elif update.message:
if update.message.caption is not None:
self.text = update.message.caption
else:
self.text = update.message.text
self.update_type = UpdateType.message
if octobot.Database.redis is not None:
octobot.Database.redis.set(
octobot.utils.generate_edit_id(self.update.message), 0)
octobot.Database.redis.expire(
octobot.utils.generate_edit_id(self.update.message), 30)
elif update.edited_message:
if octobot.Database.redis is None:
raise octobot.StopHandling
else:
self.update.message = self.update.edited_message
if octobot.Database.redis.exists(
octobot.utils.generate_edit_id(self.update.message)):
self.edit_tgt = int(
octobot.Database.redis.get(
octobot.utils.generate_edit_id(
self.update.message)))
if self.edit_tgt == 0:
logger.debug(
"Not handling update %s cause invalid edit target",
update.update_id)
raise octobot.StopHandling
octobot.Database.redis.delete(
octobot.utils.generate_edit_id(self.update.message))
self.update_type = UpdateType.edited_message
if update.message.caption is not None:
self.text = update.message.caption
else:
self.text = update.message.text
else:
logger.debug(
"Not handling update %s cause not available in database",
update.update_id)
raise octobot.StopHandling
logger.debug("edit target = %s", self.edit_tgt)
else:
raise octobot.exceptions.UnknownUpdate(
"Failed to determine update type for update %s",
update.to_dict())
if self.text is None:
self.text = ''
logger.debug("update type for id %s is %s", self.update.update_id,
self.update_type)
self.query = " ".join(self.text.split(" ")[1:])
try:
self.args = shlex.split(self.query)
except ValueError:
self.args = self.query.split(" ")
def error_handler(update: Update, context: CallbackContext):
logger.error('Update "{}" caused error "{}"'.format(
json.dumps(update.to_dict(), indent=4), context.error))