def add_keyword(bot, update, chat_data): user = User.from_telegram_object(update.effective_user) if check_suggestion_limit(bot, update, user): return kw = update.message.text bot_to_edit = chat_data.get('edit_bot') kw = helpers.format_keyword(kw) # Sanity checks if kw in settings.FORBIDDEN_KEYWORDS: update.message.reply_text('The keyword {} is forbidden.'.format(kw)) return if len(kw) <= 1: update.message.reply_text('Keywords must be longer than 1 character.') return if len(kw) >= 20: update.message.reply_text( 'Keywords must not be longer than 20 characters.') # Ignore duplicates try: Keyword.get((Keyword.name == kw) & (Keyword.entity == bot_to_edit)) return except Keyword.DoesNotExist: pass Suggestion.add_or_update(user=user, action='add_keyword', subject=bot_to_edit, value=kw) set_keywords(bot, update, chat_data, bot_to_edit) Statistic.of(update, 'added keyword to'.format(kw), bot_to_edit.username)
def send_category(bot, update, chat_data, category): uid = util.uid_from_update(update) cid = update.effective_chat.id bots = Bot.of_category_without_new( category)[:settings.MAX_BOTS_PER_MESSAGE] bots_with_description = [b for b in bots if b.description is not None] detailed_buttons_enabled = len( bots_with_description) > 0 and util.is_private_message(update) callback = CallbackActions.SEND_BOT_DETAILS if detailed_buttons_enabled: buttons = [ InlineKeyboardButton( x.username, callback_data=util.callback_for_action(callback, {"id": x.id}), ) for x in bots_with_description ] else: buttons = [] menu = util.build_menu(buttons, 2) menu.insert( 0, [ InlineKeyboardButton( captions.BACK, callback_data=util.callback_for_action( CallbackActions.SELECT_CATEGORY), ), InlineKeyboardButton( "Show in BotList", url="http://t.me/botlist/{}".format( category.current_message_id), ), InlineKeyboardButton("Share", switch_inline_query=category.name), ], ) txt = "There are *{}* bots in the category *{}*:\n\n".format( len(bots), str(category)) if uid in settings.MODERATORS and util.is_private_message(update): # append admin edit buttons txt += "\n".join(["{} ā /edit{} š".format(b, b.id) for b in bots]) else: txt += "\n".join([str(b) for b in bots]) if detailed_buttons_enabled: txt += "\n\n" + util.action_hint( "Press a button below to get a detailed description.") reply_markup = InlineKeyboardMarkup(menu) reply_markup, callback = botlistchat.append_restricted_delete_button( update, chat_data, reply_markup) msg = bot.formatter.send_or_edit(cid, txt, to_edit=util.mid_from_update(update), reply_markup=reply_markup) callback(msg) Statistic.of(update, "menu", "of category {}".format(str(category)), Statistic.ANALYSIS)
def add_favorite(bot, update, item: Bot, callback_alert=None): user = User.from_update(update) uid = util.uid_from_update(update) mid = util.mid_from_update(update) from components.basic import main_menu_buttons main_menu_markup = ReplyKeyboardMarkup(main_menu_buttons(uid in settings.MODERATORS)) fav, created = Favorite.add(user=user, item=item) if created: Statistic.of(user, 'add-favorite', item.username) text = mdformat.love("{} added to your {}favorites.".format(fav.bot, '' if callback_alert else '/')) if callback_alert: update.callback_query.answer(text=text, show_alert=False) else: msg = util.send_md_message(bot, uid, text, to_edit=mid, reply_markup=main_menu_markup) mid = msg.message_id util.wait(bot, update) send_favorites_list(bot, update, to_edit=mid) else: text = mdformat.none_action( "{} is already a favorite of yours.{}".format(fav.bot, '' if callback_alert else ' /favorites')) if callback_alert: update.callback_query.answer(text=text, show_alert=False) else: util.send_md_message(bot, uid, text, reply_markup=main_menu_markup) return ConversationHandler.END
def add_or_update(user, action, subject, value): from models import Statistic # value may be None already_exists = Suggestion.get_pending(action, subject, user, value) if already_exists: # Does the new suggestion reset the value? if action == 'remove_keyword': try: kw = Keyword.get(entity=subject, name=value) kw.delete_instance() except Keyword.DoesNotExist: pass elif action == 'add_keyword': return # TODO: is this right? elif value == getattr(already_exists.subject, action): already_exists.delete_instance() return None already_exists.value = value already_exists.save() Statistic.of(user, 'made changes to their suggestion: ', str(already_exists)) return already_exists else: new_suggestion = Suggestion(user=user, action=action, date=datetime.date.today(), subject=subject, value=value) new_suggestion.save() Statistic.of(user, 'suggestion', new_suggestion._md_plaintext()) return new_suggestion
def delete_bot(bot, update, to_edit: Bot): username = to_edit.username to_edit.disable(Bot.DisabledReason.banned) to_edit.save() bot.formatter.send_or_edit(update.effective_user.id, "Bot has been disabled and banned.", to_edit=util.mid_from_update(update)) Statistic.of(update, 'disable', username, Statistic.IMPORTANT)
def apply_all_changes(bot, update, chat_data, to_edit): user = User.from_update(update) user_suggestions = Suggestion.select_all_of_user(user) for suggestion in user_suggestions: suggestion.apply() refreshed_bot = Bot.get(id=to_edit.id) edit_bot(bot, update, chat_data, refreshed_bot) Statistic.of(update, "apply", refreshed_bot.username)
def _input_failed(bot, update, chat_data, text): chat_id = util.uid_from_update(update) bot.formatter.send_failure(chat_id, text) Statistic.of( update, "error", "input failed in admin menu for {}".format(text), Statistic.ANALYSIS, ) chat_data["add_bot_message"] = None
def check_suggestion_limit(bot, update, user): cid = update.effective_chat.id if Suggestion.over_limit(user): bot.formatter.send_failure( cid, "You have reached the limit of {} suggestions. Please wait for " "the Moderators to approve of some of them.".format( settings.SUGGESTION_LIMIT)) Statistic.of(update, 'hit the suggestion limit') return True return False
def _too_many_favorites_handler(bot, update, user): uid = util.uid_from_update(update) any_removed = False while too_many_favorites(user): oldest = Favorite.get_oldest(user) oldest.delete_instance() any_removed = True Statistic.of(update, 'had to lose a favorite because HE HAD TOO F****N MANY š¬') if any_removed: txt = "You have too many favorites, _they do not fit into a single message_. That's why I removed your " \ "oldest bot, *{}*, from your list of favorites.".format(oldest.bot if oldest.bot else oldest.custom_bot) util.send_md_message(bot, uid, txt)
def set_notifications(bot, update, value: bool): cid = update.effective_chat.id try: notifications = Notifications.get(Notifications.chat_id == cid) except Notifications.DoesNotExist: notifications = Notifications(chat_id=cid) notifications.enabled = value notifications.save() Statistic.of(update, ('enabled' if value else 'disabled') + ' notifications for their group {}'.format(cid)) msg = util.success("Nice! Notifications enabled." ) if value else "Ok, notifications disabled." msg += '\nYou can always adjust this setting with the /subscribe command.' bot.formatter.send_or_edit(cid, msg, to_edit=util.mid_from_update(update)) return ConversationHandler.END
def ban_user(_bot, update, user: User, ban_state: bool): if user.banned and ban_state is True: update.message.reply_text( mdformat.none_action("User {} is already banned.".format(user)), parse_mode="markdown", ) raise DispatcherHandlerStop if not user.banned and ban_state is False: update.message.reply_text( mdformat.none_action("User {} is not banned.".format(user)), parse_mode="markdown", ) raise DispatcherHandlerStop user.banned = ban_state if ban_state is True: with db.atomic(): user_submissions = Bot.select().where( (Bot.approved == False) & (Bot.submitted_by == user) # TODO: does this need to include `Bot.deleted == True`? ) for b in user_submissions: b.delete_instance() users_suggestions = Suggestion.select().where( (Suggestion.executed == False) & (Suggestion.user == user)) for s in users_suggestions: s.delete_instance() update.message.reply_text( mdformat.success( "User {} banned, all bot submissions and suggestions removed.". format(user)), parse_mode="markdown", ) Statistic.of(update, "ban", user.markdown_short) else: update.message.reply_text(mdformat.success( "User {} unbanned.".format(user)), parse_mode="markdown") Statistic.of(update, "unban", user.markdown_short) user.save()
def send_botlist(bot, update, resend=False, silent=False): log.info("Re-sending BotList..." if resend else "Updating BotList...") channel = helpers.get_channel() revision = Revision.get_instance() revision.nr += 1 revision.save() all_categories = Category.select_all() botlist = BotList(bot, update, channel, resend, silent) if resend: botlist.delete_full_botlist() botlist.update_intro() botlist.update_categories(all_categories) botlist.update_new_bots_list() botlist.update_category_list() botlist.send_footer() botlist.finish() channel.save() Statistic.of(update, 'send', 'botlist (resend: {})'.format(str(resend)), Statistic.IMPORTANT)
def share_with_moderator(bot, update, bot_in_question, moderator): user = User.from_update(update) buttons = [[ InlineKeyboardButton( "Yea, let me take this one!", callback_data=util.callback_for_action( CallbackActions.APPROVE_REJECT_BOTS, {"id": bot_in_question.id}), ) ]] reply_markup = InlineKeyboardMarkup(buttons) text = "{} thinks that you have the means to inspect this bot submission:\nā¶ļø {}".format( user.markdown_short, bot_in_question) try: util.send_md_message( bot, moderator.chat_id, text, reply_markup=reply_markup, disable_web_page_preview=True, ) answer_text = mdformat.success( "I will ask {} to have a look at this submission.".format( moderator.plaintext)) except Exception as e: answer_text = mdformat.failure( f"Could not contact {moderator.plaintext}: {e}") if update.callback_query: update.callback_query.answer(text=answer_text) Statistic.of( update, "share", "submission {} with {}".format(bot_in_question.username, moderator.plaintext), )
def send_bot_details(bot, update, chat_data, item=None): is_group = util.is_group_message(update) cid = update.effective_chat.id user = User.from_update(update) if item is None: if is_group: return try: text = update.message.text bot_in_text = re.findall(settings.REGEX_BOT_IN_TEXT, text)[0] item = Bot.by_username(bot_in_text, include_disabled=True) except Bot.DoesNotExist: update.message.reply_text( util.failure( "This bot is not in the @BotList. If you think this is a " "mistake, see the /examples for /contributing.")) return header_buttons = [] buttons = [] if item.disabled: txt = '{} {} and thus removed from the @BotList.'.format( item, Bot.DisabledReason.to_str(item.disabled_reason)) elif item.approved: # bot is already in the botlist => show information txt = item.detail_text if item.description is None and not Keyword.select().where( Keyword.entity == item).exists(): txt += ' is in the @BotList.' btn = InlineCallbackButton(captions.BACK_TO_CATEGORY, CallbackActions.SELECT_BOT_FROM_CATEGORY, {'id': item.category.id}) header_buttons.insert(0, btn) header_buttons.append( InlineKeyboardButton(captions.SHARE, switch_inline_query=item.username)) # if cid in settings.MODERATORS: header_buttons.append( InlineKeyboardButton("š Edit", callback_data=util.callback_for_action( CallbackActions.EDIT_BOT, {'id': item.id}))) # Add favorite button favorite_found = Favorite.search_by_bot(user, item) if favorite_found: buttons.append( InlineKeyboardButton(captions.REMOVE_FAVORITE_VERBOSE, callback_data=util.callback_for_action( CallbackActions.REMOVE_FAVORITE, { 'id': favorite_found.id, 'details': True }))) else: buttons.append( InlineKeyboardButton(captions.ADD_TO_FAVORITES, callback_data=util.callback_for_action( CallbackActions.ADD_TO_FAVORITES, { 'id': item.id, 'details': True }))) else: txt = '{} is currently pending to be accepted for the @BotList.'.format( item) if cid in settings.MODERATORS: header_buttons.append( InlineKeyboardButton("š Accept / Reject", callback_data=util.callback_for_action( CallbackActions.APPROVE_REJECT_BOTS, {'id': item.id}))) if buttons or header_buttons: reply_markup = InlineKeyboardMarkup( util.build_menu(buttons, n_cols=3, header_buttons=header_buttons)) else: reply_markup = None reply_markup, callback = botlistchat.append_delete_button( update, chat_data, reply_markup) # Should we ever decide to show thumbnails *shrug* # if os.path.exists(item.thumbnail_file): # preview = True # photo = '[\xad]({})'.format('{}/thumbnail/{}.jpeg'.format( # settings.API_URL, # item.username[1:] # )) # log.info(photo) # txt = photo + txt # else: # preview = False msg = bot.formatter.send_or_edit(cid, txt, to_edit=util.mid_from_update(update), reply_markup=reply_markup) callback(msg) Statistic.of(update, 'view-details', item.username, Statistic.ANALYSIS) return CallbackStates.SHOWING_BOT_DETAILS
def chosen_result(bot, update, chat_data): if update.chosen_inline_result.inline_message_id: chat_data[ 'sent_inlinequery'] = update.chosen_inline_result.inline_message_id Statistic.of(update, 'chosen-inlinequery-result', level=Statistic.ANALYSIS)
def reject_bot_submission( bot, update, args=None, to_reject=None, verbose=True, notify_submittant=True, reason=None, ): uid = util.uid_from_update(update) user = User.from_update(update) if to_reject is None: if not update.message.reply_to_message: bot.send_message( update.effective_user.id, util.failure("You must reply to a message of mine."), ) return text = update.message.reply_to_message.text reason = reason if reason else (" ".join(args) if args else None) try: update.message.delete() except: pass username = helpers.find_bots_in_text(text, first=True) if not username: bot.send_message( update.effective_user.id, util.failure( "No username in the message that you replied to."), ) return try: to_reject = Bot.by_username(username) except Bot.DoesNotExist: bot.send_message( update.effective_user.id, util.failure("Rejection failed: {} is not present in the " "database.".format(username)), ) return if to_reject.approved is True: msg = "{} has already been accepted, so it cannot be rejected anymore.".format( username) bot.sendMessage(uid, util.failure(msg)) return Statistic.of(update, "reject", to_reject.username) text = notify_submittant_rejected(bot, user, notify_submittant, reason, to_reject) to_reject.delete_instance() if verbose: bot.sendMessage(uid, text) if update.callback_query: update.callback_query.answer(text=text)