def clearall_btn(update: Update, context: CallbackContext):
query = update.callback_query
chat = update.effective_chat
message = update.effective_message
member = chat.get_member(query.from_user.id)
if query.data == "notes_rmall":
if member.status == "creator" or query.from_user.id in DRAGONS:
note_list = sql.get_all_chat_notes(chat.id)
try:
for notename in note_list:
note = notename.name.lower()
sql.rm_note(chat.id, note)
message.edit_text("Deleted all notes.")
except BadRequest:
return
if member.status == "administrator":
query.answer("Only owner of the chat can do this.")
if member.status == "member":
query.answer("You need to be admin to do this.")
elif query.data == "notes_cancel":
if member.status == "creator" or query.from_user.id in DRAGONS:
message.edit_text("Clearing of all notes has been cancelled.")
return
if member.status == "administrator":
query.answer("Only owner of the chat can do this.")
if member.status == "member":
query.answer("You need to be admin to do this.")
def clear(update: Update, context: CallbackContext):
args = context.args
chat_id = update.effective_chat.id
if len(args) >= 1:
notename = args[0].lower()
if sql.rm_note(chat_id, notename):
update.effective_message.reply_text("Successfully removed note.")
else:
update.effective_message.reply_text("That's not a note in my database!")
def get(update, context, notename, show_none=True, no_format=False):
bot = context.bot
chat_id = update.effective_message.chat.id
note_chat_id = update.effective_chat.id
note = sql.get_note(note_chat_id, notename)
message = update.effective_message # type: Optional[Message]
if note:
if MessageHandlerChecker.check_user(update.effective_user.id):
return
# If we're replying to a message, reply to that message (unless it's an error)
if message.reply_to_message:
reply_id = message.reply_to_message.message_id
else:
reply_id = message.message_id
if note.is_reply:
if JOIN_LOGGER:
try:
bot.forward_message(
chat_id=chat_id,
from_chat_id=JOIN_LOGGER,
message_id=note.value,
)
except BadRequest as excp:
if excp.message == "Message to forward not found":
message.reply_text(
"This message seems to have been lost - I'll remove it "
"from your notes list.", )
sql.rm_note(note_chat_id, notename)
else:
raise
else:
try:
bot.forward_message(
chat_id=chat_id,
from_chat_id=chat_id,
message_id=note.value,
)
except BadRequest as excp:
if excp.message == "Message to forward not found":
message.reply_text(
"Looks like the original sender of this note has deleted "
"their message - sorry! Get your bot admin to start using a "
"message dump to avoid this. I'll remove this note from "
"your saved notes.", )
sql.rm_note(note_chat_id, notename)
else:
raise
else:
VALID_NOTE_FORMATTERS = [
"first",
"last",
"fullname",
"username",
"id",
"chatname",
"mention",
]
valid_format = escape_invalid_curly_brackets(
note.value,
VALID_NOTE_FORMATTERS,
)
if valid_format:
if not no_format:
if "%%%" in valid_format:
split = valid_format.split("%%%")
if all(split):
text = random.choice(split)
else:
text = valid_format
else:
text = valid_format
else:
text = valid_format
text = text.format(
first=escape_markdown(message.from_user.first_name),
last=escape_markdown(
message.from_user.last_name
or message.from_user.first_name, ),
fullname=escape_markdown(
" ".join([
message.from_user.first_name,
message.from_user.last_name
] if message.from_user.last_name else
[message.from_user.first_name], ), ),
username="******" + message.from_user.username
if message.from_user.username else mention_markdown(
message.from_user.id,
message.from_user.first_name,
),
mention=mention_markdown(
message.from_user.id,
message.from_user.first_name,
),
chatname=escape_markdown(
message.chat.title if message.chat.type != "private"
else message.from_user.first_name, ),
id=message.from_user.id,
)
else:
text = ""
keyb = []
parseMode = ParseMode.MARKDOWN
buttons = sql.get_buttons(note_chat_id, notename)
if no_format:
parseMode = None
text += revert_buttons(buttons)
else:
keyb = build_keyboard(buttons)
keyboard = InlineKeyboardMarkup(keyb)
try:
if note.msgtype in (sql.Types.BUTTON_TEXT, sql.Types.TEXT):
bot.send_message(
chat_id,
text,
reply_to_message_id=reply_id,
parse_mode=parseMode,
disable_web_page_preview=True,
reply_markup=keyboard,
)
else:
ENUM_FUNC_MAP[note.msgtype](
chat_id,
note.file,
caption=text,
reply_to_message_id=reply_id,
parse_mode=parseMode,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest as excp:
if excp.message == "Entity_mention_user_invalid":
message.reply_text(
"Looks like you tried to mention someone I've never seen before. If you really "
"want to mention them, forward one of their messages to me, and I'll be able "
"to tag them!", )
elif FILE_MATCHER.match(note.value):
message.reply_text(
"This note was an incorrectly imported file from another bot - I can't use "
"it. If you really need it, you'll have to save it again. In "
"the meantime, I'll remove it from your notes list.", )
sql.rm_note(note_chat_id, notename)
else:
message.reply_text(
"This note could not be sent, as it is incorrectly formatted. Ask in "
f"@{SUPPORT_CHAT} if you can't figure out why!", )
LOGGER.exception(
"Could not parse message #%s in chat %s",
notename,
str(note_chat_id),
)
LOGGER.warning("Message was: %s", str(note.value))
return
if show_none:
message.reply_text("This note doesn't exist")