def list_handlers(bot: Bot, update: Update):
chat = update.effective_chat
all_handlers = sql.get_chat_triggers(chat.id)
update_chat_title = chat.title
message_chat_title = update.effective_message.chat.title
if update_chat_title == message_chat_title:
BASIC_FILTER_STRING = "<b>Filters in this chat:</b>\n"
else:
BASIC_FILTER_STRING = f"<b>Filters in {update_chat_title}</b>:\n"
if not all_handlers:
if update_chat_title == message_chat_title:
update.effective_message.reply_text("No filters are active here!")
else:
update.effective_message.reply_text(f"No filters are active in <b>{update_chat_title}</b>!",
parse_mode=telegram.ParseMode.HTML)
return
filter_list = ""
for keyword in all_handlers:
entry = f" • <code>{html.escape(keyword)}</code>\n"
if len(entry) + len(filter_list) + len(BASIC_FILTER_STRING) > telegram.MAX_MESSAGE_LENGTH:
filter_list = BASIC_FILTER_STRING + html.escape(filter_list)
update.effective_message.reply_text(filter_list, parse_mode=telegram.ParseMode.HTML)
filter_list = entry
else:
filter_list += entry
if not filter_list == BASIC_FILTER_STRING:
filter_list = BASIC_FILTER_STRING + filter_list
update.effective_message.reply_text(filter_list, parse_mode=telegram.ParseMode.HTML)
def rmall_filters(update, context):
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
usermem = chat.get_member(user.id)
if not usermem.status == "creator":
msg.reply_text("This command can be only used by chat OWNER!")
return
allfilters = sql.get_chat_triggers(chat.id)
if not allfilters:
msg.reply_text("No filters in this chat, nothing to stop!")
return
count = 0
filterlist = []
for x in allfilters:
count += 1
filterlist.append(x)
for i in filterlist:
sql.remove_filter(chat.id, i)
return msg.reply_text(f"Cleaned {count} filters in {chat.title}")
def addnew_filter(update, chat_id, keyword, text, file_type, file_id, buttons):
msg = update.effective_message
totalfilt = sql.get_chat_triggers(chat_id)
if len(totalfilt) >= 150: # Idk why i made this like function....
msg.reply_text("This group has reached its max filters limit of 150.")
return False
sql.new_add_filter(chat_id, keyword, text, file_type, file_id, buttons)
return True
def list_handlers(update, context):
chat = update.effective_chat
user = update.effective_user
conn = connected(context.bot, update, chat, user.id, need_admin=False)
if not conn is False:
chat_id = conn
chat_name = dispatcher.bot.getChat(conn).title
filter_list = "*Filter in {}:*\n"
else:
chat_id = update.effective_chat.id
if chat.type == "private":
chat_name = "Local filters"
filter_list = "*local filters:*\n"
else:
chat_name = chat.title
filter_list = "*Filters in {}*:\n"
all_handlers = sql.get_chat_triggers(chat_id)
totalf = sql.get_chat_triggers(chat_id)
filter_list += "*Total Filters:*" + " " + str(len(totalf)) + " \n"
if not all_handlers:
send_message(update.effective_message,
"No filters saved in {}!".format(chat_name))
return
for keyword in all_handlers:
entry = " • `{}`\n".format(escape_markdown(keyword))
if len(entry) + len(filter_list) > telegram.MAX_MESSAGE_LENGTH:
send_message(
update.effective_message,
filter_list.format(chat_name),
parse_mode=telegram.ParseMode.MARKDOWN,
)
filter_list += entry
else:
filter_list += entry
send_message(
update.effective_message,
filter_list.format(chat_name),
parse_mode=telegram.ParseMode.MARKDOWN,
)
def addnew_filter(update, chat_id, keyword, text, file_type, file_id, buttons):
msg = update.effective_message
totalfilt = sql.get_chat_triggers(chat_id)
if len(totalfilt) >= 100: # Idk why i made this like function....
msg.reply_text("Bu qrup maksimum filtr sayına çatıb. Maksimum filtr sayı 100-dür.")
return False
else:
sql.new_add_filter(chat_id, keyword, text, file_type, file_id, buttons)
return True
def reply_filter(bot: Bot, update: Update):
chat = update.effective_chat
message = update.effective_message
to_match = extract_text(message)
if not to_match:
return
chat_filters = sql.get_chat_triggers(chat.id)
for keyword in chat_filters:
pattern = r"( |^|[^\w])" + keyword + r"( |$|[^\w])"
match = regex_searcher(pattern, to_match)
if not match:
#Skip to next item
continue
if match:
filt = sql.get_filter(chat.id, keyword)
if filt.is_sticker:
message.reply_sticker(filt.reply)
elif filt.is_document:
message.reply_document(filt.reply)
elif filt.is_image:
message.reply_photo(filt.reply)
elif filt.is_audio:
message.reply_audio(filt.reply)
elif filt.is_voice:
message.reply_voice(filt.reply)
elif filt.is_video:
message.reply_video(filt.reply)
elif filt.has_markdown:
buttons = sql.get_buttons(chat.id, filt.keyword)
keyb = build_keyboard(buttons)
keyboard = InlineKeyboardMarkup(keyb)
try:
message.reply_text(filt.reply, parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
reply_markup=keyboard)
except BadRequest as excp:
if excp.message == "Unsupported url protocol":
message.reply_text("You seem to be trying to use an unsupported url protocol. Telegram "
"doesn't support buttons for some protocols, such as tg://. Please try "
f"again, or ask in {SUPPORT_CHAT} for help.")
elif excp.message == "Reply message not found":
bot.send_message(chat.id, filt.reply, parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
reply_markup=keyboard)
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.warning("Message %s could not be parsed", str(filt.reply))
LOGGER.exception("Could not parse filter %s in chat %s", str(filt.keyword), str(chat.id))
else:
# LEGACY - all new filters will have has_markdown set to True.
message.reply_text(filt.reply)
break
def reply_filter(bot: Bot, update: Update):
chat = update.effective_chat
message = update.effective_message
to_match = extract_text(message)
if not to_match:
return
chat_filters = sql.get_chat_triggers(chat.id)
for keyword in chat_filters:
pattern = r"( |^|[^\w])" + keyword + r"( |$|[^\w])"
match = regex_searcher(pattern, to_match)
if not match:
#Skip to next item
continue
if match:
filt = sql.get_filter(chat.id, keyword)
if filt.is_sticker:
message.reply_sticker(filt.reply)
elif filt.is_document:
message.reply_document(filt.reply)
elif filt.is_image:
message.reply_photo(filt.reply)
elif filt.is_audio:
message.reply_audio(filt.reply)
elif filt.is_voice:
message.reply_voice(filt.reply)
elif filt.is_video:
message.reply_video(filt.reply)
elif filt.has_markdown:
buttons = sql.get_buttons(chat.id, filt.keyword)
keyb = build_keyboard(buttons)
keyboard = InlineKeyboardMarkup(keyb)
try:
message.reply_text(filt.reply, parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
reply_markup=keyboard)
except BadRequest as excp:
if excp.message == "Desteklenmeyen URL protokolü":
message.reply_text("Desteklenmeyen bir URL protokolü kullanmaya çalışıyor gibi görünüyorsunuz. Telegram "
"bazı protokoller için düğmeleri desteklemiyor, gibi tg://. Please try "
f"tekrar, ya da sor {SUPPORT_CHAT} yardım için.")
elif excp.message == "Yanıt mesajı bulunamadı":
bot.send_message(chat.id, filt.reply, parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
reply_markup=keyboard)
else:
message.reply_text("Bu not yanlış biçimlendirildiği için gönderilemedi. Sor"
f"{SUPPORT_CHAT} nedenini anlayamıyorsan!")
LOGGER.warning("%S iletisi ayrıştırılamadı", str(filt.reply))
LOGGER.exception("%S sohbetindeki %s filtresi ayrıştırılamadı", str(filt.keyword), str(chat.id))
else:
# LEGACY - all new filters will have has_markdown set to True.
message.reply_text(filt.reply)
break
def addnew_filter(update, chat_id, keyword, text, file_type, file_id, buttons):
chat = update.effective_chat
chat_id = update.effective_chat.id
user = update.effective_user
message = update.effective_message # type: Optional[Message]
user_member = chat.get_member(user.id)
if user_member.can_change_info == False:
message.reply_text("You don't have permission to do this!")
return
totalfilt = sql.get_chat_triggers(chat_id)
if len(totalfilt) >= 150: # Idk why i made this like function....
msg.reply_text("This group has reached its max filters limit of 150.")
return False
else:
sql.new_add_filter(chat_id, keyword, text, file_type, file_id, buttons)
return True
def stop_filter(update, context):
chat = update.effective_chat
user = update.effective_user
args = update.effective_message.text.split(None, 1)
conn = connected(context.bot, update, chat, user.id)
if not conn is 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 filters"
else:
chat_name = chat.title
if len(args) < 2:
send_message(update.effective_message,
"Excuse me sir, What should i stop?")
return
chat_filters = sql.get_chat_triggers(chat_id)
if not chat_filters:
send_message(update.effective_message, "No filters active here!")
return
for keyword in chat_filters:
if keyword == args[1]:
sql.remove_filter(chat_id, args[1])
send_message(
update.effective_message,
"Okay sir, This filter already stoped in *{}*.".format(
chat_name),
parse_mode=telegram.ParseMode.MARKDOWN,
)
raise DispatcherHandlerStop
send_message(
update.effective_message,
"That's not a filter - Click: /filters to get currently active filters.",
)
def stop_filter(update, context):
chat = update.effective_chat
user = update.effective_user
args = update.effective_message.text.split(None, 1)
conn = connected(context.bot, update, chat, user.id)
if not conn is 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 filters"
else:
chat_name = chat.title
if len(args) < 2:
send_message(update.effective_message, "Yoxluğu stop eləyim?")
return
chat_filters = sql.get_chat_triggers(chat_id)
if not chat_filters:
send_message(update.effective_message, "Burada aktiv filtr yoxdur!")
return
for keyword in chat_filters:
if keyword == args[1]:
sql.remove_filter(chat_id, args[1])
send_message(
update.effective_message,
"Okey *{}* qrupunda bu filtri dayandırdım.".format(
chat_name),
parse_mode=telegram.ParseMode.MARKDOWN,
)
raise DispatcherHandlerStop
send_message(
update.effective_message,
"Bu bir filtr deyil - /filters yazaraq aktiv filtrlərə bax bilərsiniz.",
)
def stop_filter(bot: Bot, update: Update):
chat = update.effective_chat
msg = update.effective_message
args = msg.text.split(None, 1)
if len(args) < 2:
return
chat_filters = sql.get_chat_triggers(chat.id)
if not chat_filters:
msg.reply_text("No filters are active here!")
return
for keyword in chat_filters:
if keyword == args[1]:
sql.remove_filter(chat.id, args[1])
msg.reply_text("Yep, I'll stop replying to that.")
raise DispatcherHandlerStop
msg.reply_text("That's not a current filter - run /filters for all active filters.")
def stop_filter(bot: Bot, update: Update):
chat = update.effective_chat
msg = update.effective_message
args = msg.text.split(None, 1)
if len(args) < 2:
return
chat_filters = sql.get_chat_triggers(chat.id)
if not chat_filters:
msg.reply_text("Burada etkin filtre yok!")
return
for keyword in chat_filters:
if keyword == args[1]:
sql.remove_filter(chat.id, args[1])
msg.reply_text("Evet, buna cevap vermeyi bırakacağım.")
raise DispatcherHandlerStop
msg.reply_text("Bu geçerli bir filtre değil - tüm etkin filtreler için çalıştır /filters.")
def stop_filter(update, context):
chat = update.effective_chat
user = update.effective_user
args = update.effective_message.text.split(None, 1)
conn = connected(context.bot, update, chat, user.id)
if not conn is 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 filters"
else:
chat_name = chat.title
if len(args) < 2:
send_message(update.effective_message, "What should i stop?")
return
chat_filters = sql.get_chat_triggers(chat_id)
if not chat_filters:
send_message(update.effective_message, "No filters active here!")
return
for keyword in chat_filters:
if keyword == args[1]:
sql.remove_filter(chat_id, args[1])
send_message(
update.effective_message,
"Oke, saya berhenti menjawab filter *{}*.".format(chat_name),
parse_mode=telegram.ParseMode.MARKDOWN,
)
raise DispatcherHandlerStop
send_message(
update.effective_message,
"Itu bukan filter - Klik: /filters untuk menampilkan filter yang tersedia.",
)
def rmall_callback(update, context):
query = update.callback_query
chat = update.effective_chat
msg = update.effective_message
member = chat.get_member(query.from_user.id)
if query.data == 'filters_rmall':
if member.status == "creator" or query.from_user.id in DRAGONS:
allfilters = sql.get_chat_triggers(chat.id)
if not allfilters:
msg.edit_text("Burada heç bir filtr yoxdur!")
return
count = 0
filterlist = []
for x in allfilters:
count += 1
filterlist.append(x)
for i in filterlist:
sql.remove_filter(chat.id, i)
msg.edit_text(
f"{chat.title} qrupunda {count} ədəd filtr dayandırıldı")
if member.status == "administrator":
query.answer("Yalnız qrup sahibi bunu edə bilər.")
if member.status == "member":
query.answer("Əvvəlcə admin olmalısan.")
elif query.data == 'filters_cancel':
if member.status == "creator" or query.from_user.id in DRAGONS:
msg.edit_text("Bütün filtrlərin silinməsi dayandırıldı.")
return
if member.status == "administrator":
query.answer("Yalnız qrup sahibi bunu edə bilər.")
if member.status == "member":
query.answer("Əvvəlcə admin olmalısan.")
def rmall_callback(update, context):
query = update.callback_query
chat = update.effective_chat
msg = update.effective_message
member = chat.get_member(query.from_user.id)
if query.data == "filters_rmall":
if member.status == "creator" or query.from_user.id in DRAGONS:
allfilters = sql.get_chat_triggers(chat.id)
if not allfilters:
msg.edit_text("No filters in this chat, nothing to stop!")
return
count = 0
filterlist = []
for x in allfilters:
count += 1
filterlist.append(x)
for i in filterlist:
sql.remove_filter(chat.id, i)
msg.edit_text(f"Cleaned {count} filters in {chat.title}")
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 == "filters_cancel":
if member.status == "creator" or query.from_user.id in DRAGONS:
msg.edit_text("Clearing of all filters 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 __chat_settings__(chat_id, user_id):
cust_filters = sql.get_chat_triggers(chat_id)
return "There are currently `{}` custom filters here.".format(
len(cust_filters))
def reply_filter(update, context):
chat = update.effective_chat # type: Optional[Chat]
message = update.effective_message # type: Optional[Message]
if not update.effective_user or update.effective_user.id == 777000:
return
to_match = extract_text(message)
if not to_match:
return
chat_filters = sql.get_chat_triggers(chat.id)
for keyword in chat_filters:
pattern = r"( |^|[^\w])" + re.escape(keyword) + r"( |$|[^\w])"
if re.search(pattern, to_match, flags=re.IGNORECASE):
if MessageHandlerChecker.check_user(update.effective_user.id):
return
filt = sql.get_filter(chat.id, keyword)
if filt.reply == "there is should be a new reply":
buttons = sql.get_buttons(chat.id, filt.keyword)
keyb = build_keyboard_parser(context.bot, chat.id, buttons)
keyboard = InlineKeyboardMarkup(keyb)
VALID_WELCOME_FORMATTERS = [
"first",
"last",
"fullname",
"username",
"id",
"chatname",
"mention",
]
if filt.reply_text:
if "%%%" in filt.reply_text:
split = filt.reply_text.split("%%%")
if all(split):
text = random.choice(split)
else:
text = filt.reply_text
else:
text = filt.reply_text
if text.startswith("~!") and text.endswith("!~"):
sticker_id = text.replace("~!", "").replace("!~", "")
try:
context.bot.send_sticker(
chat.id,
sticker_id,
reply_to_message_id=message.message_id,
)
return
except BadRequest as excp:
if (excp.message ==
"Wrong remote file identifier specified: wrong padding in the string"
):
context.bot.send_message(
chat.id,
"Message couldn't be sent, Is the sticker id valid?",
)
return
else:
LOGGER.exception("Error in filters: " +
excp.message)
return
valid_format = escape_invalid_curly_brackets(
text, VALID_WELCOME_FORMATTERS)
if valid_format:
filtext = 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:
filtext = ""
else:
filtext = ""
if filt.file_type in (sql.Types.BUTTON_TEXT, sql.Types.TEXT):
try:
context.bot.send_message(
chat.id,
markdown_to_html(filtext),
reply_to_message_id=message.message_id,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest as excp:
error_catch = get_exception(excp, filt, chat)
if error_catch == "noreply":
try:
context.bot.send_message(
chat.id,
markdown_to_html(filtext),
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest as excp:
LOGGER.exception("Error in filters: " +
excp.message)
send_message(
update.effective_message,
get_exception(excp, filt, chat),
)
else:
try:
send_message(
update.effective_message,
get_exception(excp, filt, chat),
)
except BadRequest as excp:
LOGGER.exception("Failed to send message: " +
excp.message)
pass
else:
try:
ENUM_FUNC_MAP[filt.file_type](
chat.id,
filt.file_id,
caption=markdown_to_html(filtext),
reply_to_message_id=message.message_id,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest:
send_message(
message,
"I don't have the permission to send the content of the filter.",
)
break
else:
if filt.is_sticker:
message.reply_sticker(filt.reply)
elif filt.is_document:
message.reply_document(filt.reply)
elif filt.is_image:
message.reply_photo(filt.reply)
elif filt.is_audio:
message.reply_audio(filt.reply)
elif filt.is_voice:
message.reply_voice(filt.reply)
elif filt.is_video:
message.reply_video(filt.reply)
elif filt.has_markdown:
buttons = sql.get_buttons(chat.id, filt.keyword)
keyb = build_keyboard_parser(context.bot, chat.id, buttons)
keyboard = InlineKeyboardMarkup(keyb)
try:
send_message(
update.effective_message,
filt.reply,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest as excp:
if excp.message == "Unsupported url protocol":
try:
send_message(
update.effective_message,
"You seem to be trying to use an unsupported url protocol. "
"Telegram doesn't support buttons for some protocols, such as tg://. Please try "
"again...",
)
except BadRequest as excp:
LOGGER.exception("Error in filters: " +
excp.message)
pass
elif excp.message == "Reply message not found":
try:
context.bot.send_message(
chat.id,
filt.reply,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest as excp:
LOGGER.exception("Error in filters: " +
excp.message)
pass
else:
try:
send_message(
update.effective_message,
"This message couldn't be sent as it's incorrectly formatted.",
)
except BadRequest as excp:
LOGGER.exception("Error in filters: " +
excp.message)
pass
LOGGER.warning("Message %s could not be parsed",
str(filt.reply))
LOGGER.exception(
"Could not parse filter %s in chat %s",
str(filt.keyword),
str(chat.id),
)
else:
# LEGACY - all new filters will have has_markdown set to True.
try:
send_message(update.effective_message, filt.reply)
except BadRequest as excp:
LOGGER.exception("Error in filters: " + excp.message)
pass
break
def __chat_settings__(chat_id, user_id):
cust_filters = sql.get_chat_triggers(chat_id)
return "Şu anda burada `{}`özel filtre var.".format(len(cust_filters))
def reply_filter(update, context):
chat = update.effective_chat # type: Optional[Chat]
message = update.effective_message # type: Optional[Message]
if not update.effective_user or update.effective_user.id == 777000:
return
to_match = extract_text(message)
if not to_match:
return
chat_filters = sql.get_chat_triggers(chat.id)
for keyword in chat_filters:
pattern = r"( |^|[^\w])" + re.escape(keyword) + r"( |$|[^\w])"
if re.search(pattern, to_match, flags=re.IGNORECASE):
if MessageHandlerChecker.check_user(update.effective_user.id):
return
filt = sql.get_filter(chat.id, keyword)
if filt.reply == "there is should be a new reply":
buttons = sql.get_buttons(chat.id, filt.keyword)
keyb = build_keyboard_parser(context.bot, chat.id, buttons)
keyboard = InlineKeyboardMarkup(keyb)
VALID_WELCOME_FORMATTERS = [
"first",
"last",
"fullname",
"username",
"id",
"chatname",
"mention",
]
if filt.reply_text:
if '%%%' in filt.reply_text:
split = filt.reply_text.split('%%%')
if all(split):
text = random.choice(split)
else:
text = filt.reply_text
else:
text = filt.reply_text
if text.startswith('~!') and text.endswith('!~'):
sticker_id = text.replace('~!', '').replace('!~', '')
try:
context.bot.send_sticker(
chat.id,
sticker_id,
reply_to_message_id=message.message_id
)
return
except BadRequest as excp:
if excp.message == 'Wrong remote file identifier specified: wrong padding in the string':
context.bot.send_message(chat.id, "Mesajı göndərmək uğursuz oldu, stiker id si dəqiq doğrudur?")
return
else:
LOGGER.exception("Error in filters: " + excp.message)
return
valid_format = escape_invalid_curly_brackets(
text, VALID_WELCOME_FORMATTERS)
if valid_format:
filtext = 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:
filtext = ""
else:
filtext = ""
if filt.file_type in (sql.Types.BUTTON_TEXT, sql.Types.TEXT):
try:
context.bot.send_message(
chat.id,
markdown_to_html(filtext),
reply_to_message_id=message.message_id,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest as excp:
error_catch = get_exception(excp, filt, chat)
if error_catch == "noreply":
try:
context.bot.send_message(
chat.id,
markdown_to_html(filtext),
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest as excp:
LOGGER.exception("Error in filters: " +
excp.message)
send_message(
update.effective_message,
get_exception(excp, filt, chat),
)
else:
try:
send_message(
update.effective_message,
get_exception(excp, filt, chat),
)
except BadRequest as excp:
LOGGER.exception("Failed to send message: " +
excp.message)
pass
else:
ENUM_FUNC_MAP[filt.file_type](
chat.id,
filt.file_id,
caption=markdown_to_html(filtext),
reply_to_message_id=message.message_id,
parse_mode=ParseMode.HTML,
disable_web_page_preview=True,
reply_markup=keyboard,
)
break
else:
if filt.is_sticker:
message.reply_sticker(filt.reply)
elif filt.is_document:
message.reply_document(filt.reply)
elif filt.is_image:
message.reply_photo(filt.reply)
elif filt.is_audio:
message.reply_audio(filt.reply)
elif filt.is_voice:
message.reply_voice(filt.reply)
elif filt.is_video:
message.reply_video(filt.reply)
elif filt.has_markdown:
buttons = sql.get_buttons(chat.id, filt.keyword)
keyb = build_keyboard_parser(context.bot, chat.id, buttons)
keyboard = InlineKeyboardMarkup(keyb)
try:
send_message(
update.effective_message,
filt.reply,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest as excp:
if excp.message == "Unsupported url protocol":
try:
send_message(
update.effective_message,
"Görünür ki dəstəklənməyən url istifadə edirsiniz. "
"Telegram bəzi şeyləri dəstəkləmir. "
"Daha sonra yenidən cəhd edin...",
)
except BadRequest as excp:
LOGGER.exception("Error in filters: " +
excp.message)
pass
elif excp.message == "Reply message not found":
try:
context.bot.send_message(
chat.id,
filt.reply,
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True,
reply_markup=keyboard,
)
except BadRequest as excp:
LOGGER.exception("Error in filters: " +
excp.message)
pass
else:
try:
send_message(
update.effective_message,
"Mesaj səhv formatlandığından göndərmək uğursuz oldu.",
)
except BadRequest as excp:
LOGGER.exception("Error in filters: " +
excp.message)
pass
LOGGER.warning("Message %s could not be parsed",
str(filt.reply))
LOGGER.exception(
"Could not parse filter %s in chat %s",
str(filt.keyword),
str(chat.id),
)
else:
# LEGACY - all new filters will have has_markdown set to True.
try:
send_message(update.effective_message, filt.reply)
except BadRequest as excp:
LOGGER.exception("Error in filters: " + excp.message)
pass
break
def __chat_settings__(chat_id, user_id):
cust_filters = sql.get_chat_triggers(chat_id)
return "Burada `{}` ədəd filtr mövcuddur.".format(len(cust_filters))
