def prepare_transmission(bot, update, chat_data): chat_id = util.uid_from_update(update) text = mdformat.action_hint("Notify subscribers about this update?") reply_markup = InlineKeyboardMarkup( [[ InlineKeyboardButton("☑ Notifications", callback_data=util.callback_for_action( CallbackActions.SEND_BOTLIST, {'silent': False})), InlineKeyboardButton("Silent", callback_data=util.callback_for_action( CallbackActions.SEND_BOTLIST, {'silent': True})) ], [ InlineKeyboardButton("Re-send all Messages", callback_data=util.callback_for_action( CallbackActions.SEND_BOTLIST, { 'silent': True, 're': True })) ]]) # # TODO # text = "Temporarily disabled" # reply_markup = None util.send_md_message(bot, chat_id, text, reply_markup=reply_markup)
def set_country_menu(bot, update, to_edit): uid = util.uid_from_update(update) countries = Country.select().order_by(Country.name).execute() buttons = util.build_menu([ InlineKeyboardButton('{} {}'.format(c.emojized, c.name), callback_data=util.callback_for_action( CallbackActions.SET_COUNTRY, { 'cid': c.id, 'bid': to_edit.id })) for c in countries ], 3) buttons.insert(0, [ InlineKeyboardButton(captions.BACK, callback_data=util.callback_for_action( CallbackActions.EDIT_BOT, {'id': to_edit.id})), InlineKeyboardButton("None", callback_data=util.callback_for_action( CallbackActions.SET_COUNTRY, { 'cid': 'None', 'bid': to_edit.id })), ]) return bot.formatter.send_or_edit( uid, util.action_hint( "Please select a country/language for {}".format(to_edit)), to_edit=util.mid_from_update(update), reply_markup=InlineKeyboardMarkup(buttons))
def manage_subscription(bot, update): chat_id = update.effective_chat.id user_id = update.effective_user.id if util.is_group_message(update): admins = bot.get_chat_administrators(chat_id) if user_id not in admins: bot.formatter.send_failure( chat_id, "Sorry, but only Administrators of this group are allowed " "to manage subscriptions.") return text = "Would you like to be notified when new bots arrive at the @BotList?" buttons = [[ InlineKeyboardButton(util.success("Yes"), callback_data=util.callback_for_action( CallbackActions.SET_NOTIFICATIONS, {'value': True})), InlineKeyboardButton("No", callback_data=util.callback_for_action( CallbackActions.SET_NOTIFICATIONS, {'value': False})) ]] reply_markup = InlineKeyboardMarkup(buttons) msg = util.send_md_message(bot, chat_id, text, reply_markup=reply_markup) return ConversationHandler.END
def recommend_moderator(bot, update, bot_in_question, page): uid = update.effective_user.id mid = util.mid_from_update(update) moderators = User.select().where((User.chat_id << settings.MODERATORS) & (User.chat_id != uid)) buttons = [ InlineKeyboardButton(u.first_name, callback_data=util.callback_for_action( CallbackActions.SELECT_MODERATOR, { 'bot_id': bot_in_question.id, 'uid': u.id, 'page': page })) for u in moderators ] buttons.insert( 0, InlineKeyboardButton(captions.BACK, callback_data=util.callback_for_action( CallbackActions.SWITCH_APPROVALS_PAGE, {'page': page}))) reply_markup = InlineKeyboardMarkup(util.build_menu(buttons, 1)) text = mdformat.action_hint( "Select a moderator you think is better suited to evaluate the submission of {}." .format(str(bot_in_question))) bot.formatter.send_or_edit(uid, text, to_edit=mid, reply_markup=reply_markup)
def broadcast_preview(bot, update, user_data): uid = update.effective_user.id formatted_text = update.message.text_markdown for k, v in BROADCAST_REPLACEMENTS.items(): # replace all occurences but mind escaping with \ pattern = re.compile(r"(?<!\\){}".format(k), re.IGNORECASE) formatted_text = pattern.sub(v, formatted_text) formatted_text = re.sub(r"\\({})".format(k), r"\1", formatted_text, re.IGNORECASE) user_data['broadcast'] = dict( user_data.get('broadcast', dict()), **dict(text=formatted_text, target_chat_id=settings.BOTLISTCHAT_ID)) mode = user_data['broadcast'].get('mode', 'just_send') buttons = [ InlineKeyboardButton( "Type again", callback_data=util.callback_for_action('broadcast')), InlineKeyboardButton("� Edit my message" if mode == 'editing' else "▶� Send to @BotListChat", callback_data=util.callback_for_action( 'send_broadcast', {'P4l': settings.BOTLISTCHAT_ID})), ] reply_markup = InlineKeyboardMarkup(util.build_menu(buttons, 1)) util.send_md_message(bot, uid, formatted_text, reply_markup=reply_markup) return ConversationHandler.END
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 _select_category_buttons(callback_action=None): if callback_action is None: # set default callback_action = CallbackActions.SELECT_BOT_FROM_CATEGORY categories = Category.select().order_by(Category.name.asc()).execute() buttons = util.build_menu( [ InlineKeyboardButton( "{}{}".format(emoji.emojize(c.emojis, use_aliases=True), c.name), callback_data=util.callback_for_action(callback_action, {"id": c.id}), ) for c in categories ], 2, ) buttons.insert( 0, [ InlineKeyboardButton( "🆕 New Bots", callback_data=util.callback_for_action( CallbackActions.NEW_BOTS_SELECTED), ) ], ) return buttons
def set_keywords(bot, update, chat_data, to_edit): chat_id = util.uid_from_update(update) keywords = Keyword.select().where(Keyword.entity == to_edit) chat_data['edit_bot'] = to_edit set_keywords_msgid = chat_data.get('set_keywords_msg') kw_remove_buttons = [ InlineKeyboardButton('{} ✖️'.format(x), callback_data=util.callback_for_action( CallbackActions.REMOVE_KEYWORD, { 'id': to_edit.id, 'kwid': x.id })) for x in keywords ] buttons = util.build_menu( kw_remove_buttons, 2, header_buttons=[ InlineKeyboardButton(captions.DONE, callback_data=util.callback_for_action( CallbackActions.ABORT_SETTING_KEYWORDS, {'id': to_edit.id})) ]) reply_markup = InlineKeyboardMarkup(buttons) msg = util.send_or_edit_md_message( bot, chat_id, util.action_hint( 'Send me the keywords for {} one by one...\n\n{}'.format( util.escape_markdown(to_edit.username), messages.KEYWORD_BEST_PRACTICES)), to_edit=set_keywords_msgid, reply_markup=reply_markup) chat_data['set_keywords_msg'] = msg.message_id return BotStates.SENDING_KEYWORDS
def _help_markup(): buttons = [[ InlineKeyboardButton(captions.HELP, callback_data=util.callback_for_action(const.CallbackActions.HELP)), InlineKeyboardButton(captions.CONTRIBUTING, callback_data=util.callback_for_action(const.CallbackActions.CONTRIBUTING)), InlineKeyboardButton(captions.EXAMPLES, callback_data=util.callback_for_action(const.CallbackActions.EXAMPLES)), ], [ InlineKeyboardButton('Try me inline!', switch_inline_query_current_chat='') ]] return InlineKeyboardMarkup(buttons)
def explore(bot, update, chat_data): cid = update.effective_chat.id uid = update.effective_user.id mid = util.mid_from_update(update) explorable_bots = Bot.explorable_bots() chat_data["explored"] = chat_data.get("explored", list()) # don't explore twice for explored in chat_data["explored"]: explorable_bots.remove(explored) if len(explorable_bots) == 0: util.send_md_message( bot, cid, mdformat.none_action( "You have explored all the bots. Congratulations, you might be the first 😜" ), ) return random_bot = random.choice(explorable_bots) buttons = [ [ InlineKeyboardButton( captions.ADD_TO_FAVORITES, callback_data=util.callback_for_action( CallbackActions.ADD_TO_FAVORITES, {"id": random_bot.id}), ), InlineKeyboardButton(captions.SHARE, switch_inline_query=random_bot.username), ], [ InlineKeyboardButton( random_explore_text(), callback_data=util.callback_for_action( CallbackActions.EXPLORE_NEXT), ) ], ] markup = InlineKeyboardMarkup(buttons) text = random_bot.detail_text if uid in settings.MODERATORS and util.is_private_message(update): text += "\n\n🛃 /edit{}".format(random_bot.id) msg = bot.formatter.send_or_edit(cid, text, to_edit=mid, reply_markup=markup) chat_data["explored"].append(random_bot)
def change_suggestion(bot, update, suggestion, page_handover): cid = update.effective_chat.id mid = update.effective_message.message_id text = '{}:\n\n{}'.format(str(suggestion), suggestion.value) if suggestion.action == 'description': callback_action = CallbackActions.EDIT_BOT_DESCRIPTION elif suggestion.action == 'extra': callback_action = CallbackActions.EDIT_BOT_EXTRA elif suggestion.action == 'name': callback_action = CallbackActions.EDIT_BOT_NAME elif suggestion.action == 'username': callback_action = CallbackActions.EDIT_BOT_USERNAME else: return # should not happen buttons = [[ InlineKeyboardButton(captions.BACK, callback_data=util.callback_for_action( CallbackActions.SWITCH_SUGGESTIONS_PAGE, {'page': page_handover})) ], [ InlineKeyboardButton( "{} Accept".format(Emoji.WHITE_HEAVY_CHECK_MARK), callback_data=util.callback_for_action( CallbackActions.ACCEPT_SUGGESTION, { 'id': suggestion.id, 'page': page_handover })), InlineKeyboardButton(captions.CHANGE_SUGGESTION, callback_data=util.callback_for_action( callback_action, { 'id': suggestion.id, 'page': page_handover })), InlineKeyboardButton(Emoji.CROSS_MARK, callback_data=util.callback_for_action( CallbackActions.REJECT_SUGGESTION, { 'id': suggestion.id, 'page': page_handover })) ]] reply_markup = InlineKeyboardMarkup(buttons) bot.formatter.send_or_edit(cid, text, to_edit=mid, disable_web_page_preview=True, reply_markup=reply_markup)
def delete_bot_confirm(bot, update, to_edit): chat_id = util.uid_from_update(update) reply_markup = InlineKeyboardMarkup([[ InlineKeyboardButton("Yes, delete it!", callback_data=util.callback_for_action( CallbackActions.DELETE_BOT, {'id': to_edit.id})), InlineKeyboardButton(captions.BACK, callback_data=util.callback_for_action( CallbackActions.EDIT_BOT, {'id': to_edit.id})) ]]) bot.formatter.send_or_edit(chat_id, "Are you sure?", to_edit=util.mid_from_update(update), reply_markup=reply_markup)
def append_restricted_delete_button( update, chat_data, reply_markup ) -> Tuple[Optional[ReplyMarkup], Callable[[Message], None]]: uid = update.effective_user.id command_mid = update.effective_message.message_id if not util.is_group_message(update) or not isinstance( reply_markup, InlineKeyboardMarkup): return reply_markup, lambda _: None def append_callback(message): if message is None: # No message was saved return if isinstance(message, Message): mid = message.message_id else: mid = message deletions_pending = chat_data.get("deletions_pending", dict()) if not deletions_pending.get(mid): deletions_pending[mid] = dict(user_id=uid, command_id=command_mid) chat_data["deletions_pending"] = deletions_pending buttons = reply_markup.inline_keyboard buttons.append([ InlineKeyboardButton( captions.random_done_delete(), callback_data=util.callback_for_action( CallbackActions.DELETE_CONVERSATION), ) ]) reply_markup.inline_keyboard = buttons return reply_markup, append_callback
def show_new_bots(bot, update, chat_data, back_button=False): chat_id = update.effective_chat.id channel = helpers.get_channel() buttons = [[ InlineKeyboardButton("Show in BotList", url="http://t.me/{}/{}".format( channel.username, channel.new_bots_mid)), InlineKeyboardButton("Share", switch_inline_query=messages.NEW_BOTS_INLINEQUERY) ]] if back_button: buttons[0].insert( 0, InlineKeyboardButton(captions.BACK, callback_data=util.callback_for_action( CallbackActions.SELECT_CATEGORY))) reply_markup = InlineKeyboardMarkup(buttons) reply_markup, callback = botlistchat.append_delete_button( update, chat_data, reply_markup) msg = bot.formatter.send_or_edit( chat_id, _new_bots_text(), to_edit=util.mid_from_update(update), reply_markup=reply_markup, reply_to_message_id=util.mid_from_update(update)) callback(msg) return ConversationHandler.END
def edit_bot_category(bot, update, for_bot, callback_action=None): if callback_action is None: callback_action = CallbackActions.EDIT_BOT_CAT_SELECTED uid = util.uid_from_update(update) categories = Category.select().order_by(Category.name.asc()).execute() buttons = util.build_menu( [ InlineKeyboardButton( "{}{}".format(emoji.emojize(c.emojis, use_aliases=True), c.name), callback_data=util.callback_for_action(callback_action, { "cid": c.id, "bid": for_bot.id }), ) for c in categories ], 2, ) return bot.formatter.send_or_edit( uid, util.action_hint("Please select a category" + (" for {}".format(for_bot) if for_bot else "")), to_edit=util.mid_from_update(update), reply_markup=InlineKeyboardMarkup(buttons), )
def share_with_moderator(bot, update, bot_in_question, moderator): user = User.from_update(update) answer_text = mdformat.success( "I will ask {} to have a look at this submission.".format( moderator.plaintext)) if update.callback_query: update.callback_query.answer(text=answer_text) 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) util.send_md_message(bot, moderator.chat_id, text, reply_markup=reply_markup, disable_web_page_preview=True) Statistic.of( update, 'share', 'submission {} with {}'.format(bot_in_question.username, moderator.plaintext))
def append_delete_button(update, chat_data, reply_markup): uid = update.effective_user.id cid = update.effective_chat.id command_mid = update.effective_message.message_id if not isinstance(reply_markup, InlineKeyboardMarkup): return reply_markup, callable if cid != settings.BOTLISTCHAT_ID: return reply_markup, callable def append_callback(message): if message is None: return if isinstance(message, Message): mid = message.message_id else: mid = message deletions_pending = chat_data.get('deletions_pending', dict()) if not deletions_pending.get(mid): deletions_pending[mid] = dict(user_id=uid, command_id=command_mid) chat_data['deletions_pending'] = deletions_pending buttons = reply_markup.inline_keyboard buttons.append([ InlineKeyboardButton(captions.random_done_delete(), callback_data=util.callback_for_action( CallbackActions.DELETE_CONVERSATION)) ]) reply_markup.inline_keyboard = buttons return reply_markup, append_callback
def remove_favorite_menu(bot, update): uid = util.uid_from_update(update) user = User.from_update(update) favorites = Favorite.select_all(user) fav_remove_buttons = [InlineKeyboardButton( '✖️ {}'.format(str(f.bot.username)), callback_data=util.callback_for_action(CallbackActions.REMOVE_FAVORITE, {'id': f.id})) for f in favorites] buttons = util.build_menu(fav_remove_buttons, 2, header_buttons=[ InlineKeyboardButton(captions.DONE, callback_data=util.callback_for_action(CallbackActions.SEND_FAVORITES_LIST)) ]) reply_markup = InlineKeyboardMarkup(buttons) bot.formatter.send_or_edit(uid, util.action_hint("Select favorites to remove"), to_edit=util.mid_from_update(update), reply_markup=reply_markup)
def send_broadcast(bot, update, user_data): uid = update.effective_user.id try: bc = user_data['broadcast'] text = bc['text'] recipient = bc['target_chat_id'] mode = bc.get('mode', 'just_send') except AttributeError: bot.formatter.send_failure( uid, "Missing attributes for broadcast. Aborting...") return ConversationHandler.END mid = bc.get('reply_to_message_id') if mode == 'replying': msg = util.send_md_message(bot, recipient, text, reply_to_message_id=mid) elif mode == 'editing': msg = bot.formatter.send_or_edit(recipient, text, to_edit=mid) else: msg = util.send_md_message(bot, recipient, text) # Post actions buttons = [ InlineKeyboardButton(captions.PIN, callback_data=util.callback_for_action( 'pin_message', {'mid': msg.message_id})), InlineKeyboardButton('Add "Thank You" counter', callback_data=util.callback_for_action( 'add_thank_you', { 'cid': recipient, 'mid': msg.message_id })), ] reply_markup = InlineKeyboardMarkup(util.build_menu(buttons, 1)) mid = util.mid_from_update(update) action_taken = "edited" if mode == 'editing' else "broadcasted" bot.formatter.send_or_edit(uid, mdformat.success( "Message {}.".format(action_taken)), mid, reply_markup=reply_markup)
def thank_you_markup(count=0): assert isinstance(count, int) count_caption = "" if count == 0 else mdformat.number_as_emoji(count) button = InlineKeyboardButton( "{} {}".format(messages.rand_thank_you_slang(), count_caption), callback_data=util.callback_for_action( const.CallbackActions.COUNT_THANK_YOU, {"count": count + 1}), ) return InlineKeyboardMarkup([[button]])
def add_favorite_handler(bot, update, args=None): uid = util.uid_from_update(update) from components.basic import main_menu_buttons main_menu_markup = ReplyKeyboardMarkup(main_menu_buttons(uid in settings.MODERATORS)) if args: query = ' '.join(args) if isinstance(args, list) else args try: # TODO: add multiple username = re.match(settings.REGEX_BOT_IN_TEXT, query).groups()[0] try: # TODO: get exact database matches for input without `@` item = Bot.by_username(username, include_disabled=True) return add_favorite(bot, update, item) except Bot.DoesNotExist: buttons = [ InlineKeyboardButton( "Yai!", callback_data=util.callback_for_action(CallbackActions.ADD_ANYWAY, {'u': username})), InlineKeyboardButton("Nay...", callback_data=util.callback_for_action(CallbackActions.ADD_FAVORITE)) ] reply_markup = InlineKeyboardMarkup([buttons]) util.send_md_message(bot, uid, "{} is not in the @BotList. Do you want to add it to your {} anyway?".format( username, captions.FAVORITES), reply_markup=reply_markup) except AttributeError: # invalid bot username # TODO when does this happen? update.message.reply_text( util.failure("Sorry, but that is not a valid username. Please try again. /addfav")) else: buttons = [ InlineKeyboardButton("Search inline", switch_inline_query_current_chat='') ] reply_markup = InlineKeyboardMarkup([buttons]) bot.sendMessage(uid, messages.ADD_FAVORITE, reply_markup=ForceReply(selective=True)) return ConversationHandler.END
def send_favorites_list(bot, update, to_edit=None): uid = util.uid_from_update(update) user = User.from_update(update) t = threading.Thread(target=_too_many_favorites_handler, args=(bot, update, user)) t.start() favorites = Favorite.select_all(user) buttons = [ [ InlineKeyboardButton(captions.ADD_FAVORITE, callback_data=util.callback_for_action(CallbackActions.ADD_FAVORITE)), InlineKeyboardButton(captions.REMOVE_FAVORITE, callback_data=util.callback_for_action(CallbackActions.REMOVE_FAVORITE_MENU)) ], [ InlineKeyboardButton('Layout: ' + Layouts.get_caption(user.favorites_layout), callback_data=util.callback_for_action( CallbackActions.TOGGLE_FAVORITES_LAYOUT, {'v': Layouts.get_next(user.favorites_layout)})), ], [ InlineKeyboardButton(captions.SHARE, switch_inline_query=DeepLinkingActions.FAVORITES), ] ] reply_markup = InlineKeyboardMarkup(buttons) if to_edit is None: to_edit = util.mid_from_update(update) if len(favorites) == 0: text = "You have no favorites yet." else: text = _favorites_categories_md(favorites, user.favorites_layout) bot.formatter.send_or_edit(uid, text, to_edit=to_edit, reply_markup=reply_markup)
def toggle_button(property_name, emoji, callback_action): is_pending = property_name in pending_suggestions.keys() pending_emoji = captions.SUGGESTION_PENDING_EMOJI + ' ' if is_pending else '' active = bool( pending_suggestions[property_name]) if is_pending else bool( getattr(to_edit, property_name)) active_emoji = '✔️' if active else Emoji.HEAVY_MULTIPLICATION_X caption = '{}{} {}'.format(pending_emoji, emoji, active_emoji) return InlineKeyboardButton(caption, callback_data=util.callback_for_action( callback_action, { 'id': to_edit.id, 'value': not active }))
def toggle_button(property_name, emoji, callback_action): is_pending = property_name in pending_suggestions.keys() pending_emoji = captions.SUGGESTION_PENDING_EMOJI + " " if is_pending else "" active = (bool(pending_suggestions[property_name]) if is_pending else bool(getattr(to_edit, property_name))) active_emoji = "✔️" if active else Emoji.HEAVY_MULTIPLICATION_X caption = "{}{} {}".format(pending_emoji, emoji, active_emoji) return InlineKeyboardButton( caption, callback_data=util.callback_for_action(callback_action, { "id": to_edit.id, "value": not active }), )
def accept_bot_submission(bot, update, of_bot: Bot, category): uid = util.uid_from_update(update) message_id = util.mid_from_update(update) user = User.from_update(update) try: of_bot.category = category of_bot.date_added = datetime.date.today() of_bot.approved = True of_bot.approved_by = user of_bot.save() buttons = [[ InlineKeyboardButton( "Edit {} details".format(of_bot.username), callback_data=util.callback_for_action( CallbackActions.EDIT_BOT, {"id": of_bot.id}), ) ]] reply_markup = InlineKeyboardMarkup(buttons) bot.formatter.send_or_edit( uid, "{} has been accepted to the Botlist. ".format( of_bot, settings.BOT_ACCEPTED_IDLE_TIME), to_edit=message_id, reply_markup=reply_markup, ) log_msg = "{} accepted by {}.".format(of_bot.username, uid) # notify submittant if of_bot.submitted_by != user: try: bot.sendMessage( of_bot.submitted_by.chat_id, util.success( messages.ACCEPTANCE_PRIVATE_MESSAGE.format( of_bot.username, of_bot.category)), ) log_msg += "\nUser {} was notified.".format( str(of_bot.submitted_by)) except TelegramError: log_msg += "\nUser {} could NOT be contacted/notified in private.".format( str(of_bot.submitted_by)) log.info(log_msg) except: bot.formatter.send_failure(uid, "An error has occured. Bot not added.")
def append_free_delete_button(update, reply_markup) -> Optional[ReplyMarkup]: if not util.is_group_message(update) or not isinstance( reply_markup, InlineKeyboardMarkup): return reply_markup buttons = reply_markup.inline_keyboard buttons.append([ InlineKeyboardButton( captions.random_done_delete(), callback_data=util.callback_for_action( CallbackActions.DELETE_CONVERSATION), ) ]) reply_markup.inline_keyboard = buttons return reply_markup
def bot_article(b): txt = '{} ➡️ {}'.format(messages.rand_call_to_action(), b.detail_text) txt += '\n\n' + messages.PROMOTION_MESSAGE buttons = [[ InlineKeyboardButton(captions.ADD_TO_FAVORITES, callback_data=util.callback_for_action( const.CallbackActions.ADD_TO_FAVORITES, { 'id': b.id, 'discreet': True })) ]] reply_markup = InlineKeyboardMarkup(buttons) return InlineQueryResultArticle( id=uuid4(), title=b.str_no_md, input_message_content=InputTextMessageContent( message_text=txt, parse_mode=ParseMode.MARKDOWN), description=b.description if b.description else b.name if b.name else None, reply_markup=reply_markup # thumb_url='http://www.colorcombos.com/images/colors/FF0000.png' )
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) first_row = list() 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) 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 if 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}) first_row.insert(0, btn) first_row.append( InlineKeyboardButton(captions.SHARE, switch_inline_query=item.username)) # if cid in settings.MODERATORS: first_row.append( InlineKeyboardButton("📝 Edit", callback_data=util.callback_for_action( CallbackActions.EDIT_BOT, {'id': item.id}))) else: txt = '{} is currently pending to be accepted for the @BotList.'.format( item) if cid in settings.MODERATORS: first_row.append( InlineKeyboardButton("🛃 Accept / Reject", callback_data=util.callback_for_action( CallbackActions.APPROVE_REJECT_BOTS, {'id': item.id}))) if is_group: reply_markup = InlineKeyboardMarkup([]) else: buttons = [first_row] 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 })) ]) reply_markup = InlineKeyboardMarkup(buttons) 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 approve_bots(bot, update, page=0, override_list=None): chat_id = util.uid_from_update(update) if override_list: unapproved = override_list else: unapproved = Bot.select().where(Bot.approved == False).order_by( Bot.date_added) if page < 0: page = 0 last_page = int((len(unapproved) - 1) / settings.PAGE_SIZE_BOT_APPROVAL) if page * settings.PAGE_SIZE_BOT_APPROVAL >= len(unapproved): # old item deleted, list now too small page = last_page start = page * settings.PAGE_SIZE_BOT_APPROVAL end = start + settings.PAGE_SIZE_BOT_APPROVAL has_prev_page = page > 0 has_next_page = (page + 1) * settings.PAGE_SIZE_BOT_APPROVAL < len(unapproved) unapproved = unapproved[start:end] if len(unapproved) == 0: bot.formatter.send_or_edit(chat_id, "No more unapproved bots available. " "Good job! (Is this the first time? 😂)", to_edit=util.mid_from_update(update)) return buttons = list() for x in unapproved: first_row = [ InlineKeyboardButton(x.username, url="http://t.me/{}".format(x.username[1:])) ] second_row = [ InlineKeyboardButton('👍', callback_data=util.callback_for_action( CallbackActions.ACCEPT_BOT, {'id': x.id})), InlineKeyboardButton('👎', callback_data=util.callback_for_action( CallbackActions.REJECT_BOT, { 'id': x.id, 'page': page, 'ntfc': True })), InlineKeyboardButton('🗑', callback_data=util.callback_for_action( CallbackActions.REJECT_BOT, { 'id': x.id, 'page': page, 'ntfc': False })), InlineKeyboardButton('👥🔀', callback_data=util.callback_for_action( CallbackActions.RECOMMEND_MODERATOR, { 'id': x.id, 'page': page })) ] if len(unapproved) > 1: buttons.append(first_row) buttons.append(second_row) page_arrows = list() if has_prev_page: page_arrows.append( InlineKeyboardButton('⏮', callback_data=util.callback_for_action( CallbackActions.SWITCH_APPROVALS_PAGE, {'page': -1}))) page_arrows.append( InlineKeyboardButton(Emoji.LEFTWARDS_BLACK_ARROW, callback_data=util.callback_for_action( CallbackActions.SWITCH_APPROVALS_PAGE, {'page': page - 1}))) if has_prev_page or has_next_page: page_arrows.append( InlineKeyboardButton('·{}·'.format(page + 1), callback_data=util.callback_for_action( CallbackActions.SWITCH_APPROVALS_PAGE, {'page': page}))) if has_next_page: page_arrows.append( InlineKeyboardButton(Emoji.BLACK_RIGHTWARDS_ARROW, callback_data=util.callback_for_action( CallbackActions.SWITCH_APPROVALS_PAGE, {'page': page + 1}))) page_arrows.append( InlineKeyboardButton('⏭', callback_data=util.callback_for_action( CallbackActions.SWITCH_APPROVALS_PAGE, {'page': last_page}))) buttons.append(page_arrows) reply_markup = InlineKeyboardMarkup(buttons) text = "What to do with {}?".format( util.escape_markdown(unapproved[0].username)) if len( unapproved ) == 1 else "Please select a bot you want to accept for the BotList" bot.formatter.send_or_edit(chat_id, util.action_hint(text), reply_markup=reply_markup, to_edit=util.mid_from_update(update)) return CallbackStates.APPROVING_BOTS