def rmbutton(update, context):
query = update.callback_query
userid = update.effective_user.id
match = query.data.split("_")[1]
chat = update.effective_chat
usermem = chat.get_member(userid).status
if match == "cancel" and usermem == "creator":
return query.message.edit_text("Cancelled deletion of notes.")
elif match == "true" and usermem == "creator":
allnotes = sql.get_all_chat_notes(chat.id)
count = 0
notelist = []
for notename in allnotes:
count += 1
note = notename.name.lower()
notelist.append(note)
for i in notelist:
sql.rm_note(chat.id, i)
query.message.edit_text(
f"Successfully cleaned {count} notes in {chat.title}.")
def clear(update, context):
args = context.args
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
conn = connected(context.bot, update, chat, user.id)
if not conn == False:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
chat_id = update.effective_chat.id
if chat.type == "private":
chat_name = "local notes"
else:
chat_name = chat.title
if len(args) >= 1:
notename = args[0].lower()
if sql.rm_note(chat_id, notename):
update.effective_message.reply_text(
"Successfully deleted '`{note_name}`' from {chat_name}!".
format(note_name=notename, chat_name=chat_name),
parse_mode=ParseMode.MARKDOWN,
)
else:
update.effective_message.reply_text(
"There is no such notes saved in {chat_name}!".format(
chat_name=chat_name))
else:
msg.reply_text("Yeah let me clear nothing...")
return
def clear(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
conn = connected(bot, update, chat, user.id)
if not conn == False:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
else:
chat_id = update.effective_chat.id
if chat.type == "private":
chat_name = "local notes"
else:
chat_name = chat.title
if len(args) >= 1:
notename = args[0]
if sql.rm_note(chat_id, notename):
update.effective_message.reply_text(
"Note succesfully removed from *{}*.".format(chat_name),
parse_mode=ParseMode.MARKDOWN)
else:
update.effective_message.reply_text(
"That's not a note in my database!")
def get(bot, update, notename, show_none=True, no_format=False):
chat_id = update.effective_chat.id
chat = update.effective_chat
user = update.effective_user
conn = connected(bot, update, chat, user.id, need_admin=False)
if conn:
chat_id = conn
user.id
else:
chat_id = update.effective_chat.id
note = sql.get_note(chat_id, notename)
message = update.effective_message
if note:
# 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 MESSAGE_DUMP:
try:
bot.forward_message(
chat_id=update.effective_chat.id,
from_chat_id=MESSAGE_DUMP,
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(chat_id, notename)
else:
raise
else:
try:
bot.forward_message(
chat_id=update.effective_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(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:
text = valid_format.format(
first=escape(message.from_user.first_name),
last=escape(message.from_user.last_name
or message.from_user.first_name),
fullname=" ".join([
escape(message.from_user.first_name),
escape(message.from_user.last_name),
] if message.from_user.last_name else
[escape(message.from_user.first_name)]),
username="******" + escape(message.from_user.username)
if message.from_user.username else mention_html(
message.from_user.id, message.from_user.first_name),
mention=mention_html(message.from_user.id,
message.from_user.first_name),
chatname=escape(message.chat.title)
if message.chat.type != "private" else escape(
message.from_user.first_name),
id=message.from_user.id,
)
else:
text = ""
keyb = []
parseMode = ParseMode.HTML
buttons = sql.get_buttons(chat_id, notename)
if no_format:
parseMode = None
text += revert_buttons(buttons)
else:
text = markdown_to_html(text)
keyb = build_keyboard(buttons)
keyboard = InlineKeyboardMarkup(keyb)
try:
if note.msgtype in (sql.Types.BUTTON_TEXT, sql.Types.TEXT):
bot.send_message(
update.effective_chat.id,
text,
reply_to_message_id=reply_id,
parse_mode=parseMode,
disable_web_page_preview=True,
reply_markup=keyboard,
)
else:
if (ENUM_FUNC_MAP[note.msgtype] ==
dispatcher.bot.send_sticker):
ENUM_FUNC_MAP[note.msgtype](
chat_id,
note.file,
reply_to_message_id=reply_id,
reply_markup=keyboard,
)
else:
ENUM_FUNC_MAP[note.msgtype](
update.effective_chat.id,
note.file,
caption=text,
reply_to_message_id=reply_id,
parse_mode=parseMode,
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(chat_id, notename)
else:
message.reply_text(
"This note could not be sent, as it is incorrectly formatted."
)
LOGGER.exception(
"Could not parse message #%s in chat %s",
notename,
str(chat_id),
)
LOGGER.warning("Message was: %s", str(note.value))
return
elif show_none:
message.reply_text("This note doesn't exist")
def get(bot, update, notename, show_none=True, no_format=False):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
conn = connected(bot, update, chat, user.id, need_admin=False)
if not conn == False:
chat_id = conn
send_id = user.id
else:
chat_id = update.effective_chat.id
send_id = chat_id
note = sql.get_note(chat_id, notename)
message = update.effective_message # type: Optional[Message]
if note:
# 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 MESSAGE_DUMP:
try:
bot.forward_message(chat_id=chat_id,
from_chat_id=MESSAGE_DUMP,
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(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(chat_id, notename)
else:
raise
else:
text = note.value
keyb = []
parseMode = ParseMode.MARKDOWN
buttons = sql.get_buttons(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(send_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](send_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:
print(excp.message)
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(chat_id, notename)
else:
message.reply_text(
"This note could not be sent, as it is incorrectly formatted. Ask in "
"@TheDarkW3b if you can't figure out why!")
LOGGER.exception("Could not parse message #%s in chat %s",
notename, str(chat_id))
LOGGER.warning("Message was: %s", str(note.value))
return
elif show_none:
message.reply_text("This note doesn't exist")