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 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
),
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 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 notify_submittant_rejected(bot, admin_user, notify_submittant, reason, to_reject):
notification_successful = False
msg = "{} rejected by {}.".format(to_reject.username, admin_user)
if notify_submittant or reason:
try:
if reason:
bot.send_message(
to_reject.submitted_by.chat_id,
util.failure(
messages.REJECTION_WITH_REASON.format(
to_reject.username, reason=reason
)
),
)
else:
bot.sendMessage(
to_reject.submitted_by.chat_id,
util.failure(
messages.REJECTION_PRIVATE_MESSAGE.format(to_reject.username)
),
)
msg += "\nUser {} was notified.".format(str(to_reject.submitted_by))
notification_successful = True
except TelegramError:
msg += "\nUser {} could NOT be contacted/notified in private.".format(
str(to_reject.submitted_by)
)
notification_successful = False
text = util.success("{} rejected.".format(to_reject.username))
if notification_successful is True:
text += " User {} was notified.".format(to_reject.submitted_by.plaintext)
elif notification_successful is False:
try:
text += " " + mdformat.failure(
"Could not contact {}.".format(to_reject.submitted_by.plaintext)
)
except:
pass
else:
text += " No notification sent."
return msg
def finish(self):
# set last update
self.channel.last_update = datetime.date.today()
self._save_channel()
new_bots = Bot.select_new_bots()
if not self.silent and len(new_bots) > 0:
self.notify_admin("Sending notifications to subscribers...")
subscribers = Notifications.select().where(
Notifications.enabled == True)
notification_count = 0
for sub in subscribers:
try:
util.send_md_message(
self.bot, sub.chat_id,
messages.BOTLIST_UPDATE_NOTIFICATION.format(
n_bots=len(new_bots),
new_bots=Bot.get_new_bots_markdown()))
notification_count += 1
sub.last_notification = datetime.date.today()
sub.save()
except TelegramError:
pass
self.sent[
'notifications'] = "Notifications sent to {} users.".format(
notification_count)
changes_made = len(self.sent) > 1 or len(self.sent['category']) > 0
if changes_made:
text = util.success('{}{}'.format(
'BotList updated successfully:\n\n',
mdformat.results_list(self.sent)))
else:
text = mdformat.none_action("No changes were necessary.")
log.info(self.sent)
self.bot.formatter.send_or_edit(self.chat_id,
text,
to_edit=self.message_id)
def notify_bot_offline(bot, update, args=None):
tg_user = update.message.from_user
user = User.from_telegram_object(tg_user)
reply_to = util.original_reply_id(update)
if args:
text = " ".join(args)
else:
text = update.message.text
command_no_args = (
len(re.findall(r"^/new\s*$", text)) > 0
or text.lower().strip() == "/offline@botlistbot"
)
if command_no_args:
update.message.reply_text(
util.action_hint(
"Please use this command with an argument. For example:\n/offline @mybot"
),
reply_to_message_id=reply_to,
)
return
# `#offline` is already checked by handler
try:
username = re.match(settings.REGEX_BOT_IN_TEXT, text).groups()[0]
if username == "@" + settings.SELF_BOT_NAME:
log.info("Ignoring {}".format(text))
return
except AttributeError:
if args:
update.message.reply_text(
util.failure("Sorry, but you didn't send me a bot `@username`."),
quote=True,
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply_to,
)
else:
log.info("Ignoring {}".format(text))
# no bot username, ignore update
pass
return
try:
offline_bot = Bot.get(
fn.lower(Bot.username) ** username.lower(), Bot.approved == True
)
try:
Suggestion.get(action="offline", subject=offline_bot)
except Suggestion.DoesNotExist:
suggestion = Suggestion(
user=user,
action="offline",
date=datetime.date.today(),
subject=offline_bot,
)
suggestion.save()
update.message.reply_text(
util.success(
"Thank you! We will review your suggestion and set the bot offline."
),
reply_to_message_id=reply_to,
)
except Bot.DoesNotExist:
update.message.reply_text(
util.action_hint("The bot you sent me is not in the @BotList."),
reply_to_message_id=reply_to,
)
return ConversationHandler.END
def new_bot_submission(bot, update, chat_data, args=None, bot_checker=None):
tg_user = update.message.from_user
user = User.from_telegram_object(tg_user)
if util.stop_banned(update, user):
return
reply_to = util.original_reply_id(update)
if args:
text = " ".join(args)
else:
text = update.message.text
command_no_args = (
len(re.findall(r"^/new\s*$", text)) > 0
or text.lower().strip() == "/new@botlistbot"
)
if command_no_args:
update.message.reply_text(
util.action_hint(
"Please use this command with an argument. For example:\n/new @mybot 🔎"
),
reply_to_message_id=reply_to,
)
return
# `#new` is already checked by handler
try:
username = re.match(settings.REGEX_BOT_IN_TEXT, text).groups()[0]
if username.lower() == "@" + settings.SELF_BOT_NAME.lower():
log.info("Ignoring {}".format(text))
return
except AttributeError:
if args:
update.message.reply_text(
util.failure("Sorry, but you didn't send me a bot `@username`."),
quote=True,
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply_to,
)
log.info("Ignoring {}".format(text))
# no bot username, ignore update
return
try:
new_bot = Bot.by_username(username, include_disabled=True)
if new_bot.disabled:
update.message.reply_text(
util.failure(
"{} is banned from the @BotList.".format(new_bot.username)
),
reply_to_message_id=reply_to,
)
elif new_bot.approved:
update.message.reply_text(
util.action_hint(
"Sorry fool, but {} is already in the @BotList 😉".format(
new_bot.username
)
),
reply_to_message_id=reply_to,
)
else:
update.message.reply_text(
util.action_hint(
"{} has already been submitted. Please have patience...".format(
new_bot.username
)
),
reply_to_message_id=reply_to,
)
return
except Bot.DoesNotExist:
new_bot = Bot(
revision=Revision.get_instance().next,
approved=False,
username=username,
submitted_by=user,
)
new_bot.inlinequeries = "🔎" in text
new_bot.official = "🔹" in text
# find language
languages = Country.select().execute()
for lang in languages:
if lang.emoji in text:
new_bot.country = lang
new_bot.date_added = datetime.date.today()
description_reg = re.match(settings.REGEX_BOT_IN_TEXT + " -\s?(.*)", text)
description_notify = ""
if description_reg:
description = description_reg.group(2)
new_bot.description = description
description_notify = " Your description was included."
new_bot.save()
if (
util.is_private_message(update)
and util.uid_from_update(update) in settings.MODERATORS
):
from botlistbot.components.explore import send_bot_details
send_bot_details(bot, update, chat_data, new_bot)
else:
update.message.reply_text(
util.success(
"You submitted {} for approval.{}".format(new_bot, description_notify)
),
parse_mode=ParseMode.MARKDOWN,
reply_to_message_id=reply_to,
)
# Ask the user to fill in the bot details
util.send_md_message(
bot,
update.effective_user.id,
"Congratulations, you just submitted a bot to the @BotList. Please help us fill in the details below:",
)
edit_bot(bot, update, chat_data, to_edit=new_bot)
try:
check_submission(bot, bot_checker, new_bot)
except Exception as e:
log.exception(e)
return ConversationHandler.END