def group_rank_private(bot, update, args):
user_id = update.message.from_user.id
lang = utils.get_db_lang(user_id)
if len(args) != 1:
text = get_lang.get_string(lang, "error_param_group_rank_private")
update.message.reply_text(text, parse_mode="HTML")
return
username = args[0]
if username.startswith("@"):
username = username.replace("@", "")
query = "SELECT group_id FROM supergroups_ref WHERE LOWER(username) = LOWER(%s)"
extract = database.query_r(query, username)
if len(extract) > 1:
print("error too many")
return
if len(extract) == 0:
# the group does not exist otherwise anything is returned and if None is NULL
text = get_lang.get_string(lang, "cant_check_this").format(
html.escape(username))
update.message.reply_text(text=text)
return
group_id = extract[0][0]
update.message.reply_text(text=group_rank_text(group_id, lang),
parse_mode="HTML")
def start_no_params(bot, update):
lang = utils.get_db_lang(update.message.from_user.id)
text = get_lang.get_string(lang, "help_message")
reply_markup = keyboards.help_kb(lang)
update.message.reply_text(text=text,
parse_mode="HTML",
reply_markup=reply_markup)
def feedback_reply(bot, query):
try:
query.message.edit_reply_markup(reply_markup=None)
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
lang = utils.get_db_lang(query.from_user.id)
text = get_lang.get_string(lang, "feedback_message")
bot.sendMessage(chat_id=query.from_user.id, text=text)
def private_digest(bot, query):
query.answer()
lang = utils.get_db_lang(query.from_user.id)
text = get_lang.get_string(lang, "private_digest")
reply_markup = keyboards.private_digest_kb(lang)
try:
query.edit_message_text(text=text, reply_markup=reply_markup)
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
def help_feedback(bot, query):
lang = utils.get_db_lang(query.from_user.id)
text = c.FEEDBACK_INV_CHAR + get_lang.get_string(lang, "feedback_message")
reply_markup = keyboards.back_main_private_help_kb(lang)
query.answer()
try:
query.edit_message_text(text=text,
reply_markup=reply_markup,
parse_mode='HTML')
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
def help_how_to_use_in_groups(bot, query):
lang = utils.get_db_lang(query.from_user.id)
text = get_lang.get_string(lang, "groups_working")
reply_markup = keyboards.back_main_private_help_kb(lang)
query.answer()
try:
query.edit_message_text(text=text,
reply_markup=reply_markup,
parse_mode='HTML')
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
def help_commands(bot, query):
lang = utils.get_db_lang(query.from_user.id)
text = get_lang.get_string(lang, "help_commands")
reply_markup = keyboards.advanced_commands_kb(lang)
query.answer()
try:
query.edit_message_text(text=text,
reply_markup=reply_markup,
parse_mode='HTML')
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
def change_vote(bot, query):
query.answer()
lang = utils.get_db_lang(query.from_user.id)
group_id = query.data.split(":")[1]
reply_markup = keyboards.vote_group_kb(group_id, lang)
text = utils.vote_intro(group_id, lang)
text += "\n\n"
text += get_lang.get_string(lang, "vote_from_one_to_five")
try:
query.edit_message_text(text=text, reply_markup=reply_markup)
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
def receive_feedback(self, bot, update):
sender_id = self.feedback_from.id
lang = utils.get_db_lang(sender_id)
forwarded = update.message.forward(config.FOUNDER,
disable_notification=True)
forwarded.reply_text("#id_" + str(sender_id) + "\n#feedback_from_user",
quote=True,
disable_notification=True)
forwarded.reply_text(commands_private.get_info_id(bot, sender_id),
quote=True,
disable_notification=True)
update.message.reply_text(get_lang.get_string(lang, "thanks_feedback"),
quote=True)
def vote(bot, update, args):
user_id = update.message.from_user.id
lang = utils.get_db_lang(user_id)
if len(args) != 1:
text = get_lang.get_string(lang, "insert_param_vote")
update.message.reply_text(text, parse_mode="HTML")
return
username = args[0]
if username.startswith("@"):
username = username.replace("@", "")
query = """
SELECT s.group_id, s_ref.username, s_ref.title, v.vote, v.vote_date
FROM supergroups_ref AS s_ref
RIGHT JOIN supergroups AS s
ON s_ref.group_id = s.group_id
LEFT OUTER JOIN votes AS v
ON v.group_id = s.group_id
AND v.user_id = %s
WHERE LOWER(s_ref.username) = LOWER(%s)
AND s.bot_inside = TRUE
"""
extract = database.query_r(query, user_id, username)
if len(extract) == 0:
# the group does not exist otherwise anything is returned and if None is NULL
text = get_lang.get_string(lang, "cant_vote_this")
update.message.reply_text(text=text)
return
if len(extract) > 1:
print("error too many")
return
extract = extract[0]
text = get_lang.get_string(lang, "vote_this_group").format(
extract[0], extract[1], extract[2])
if extract[3] and extract[4] is not None:
stars = emojis.STAR * extract[3]
date = utils.formatted_date_l(extract[4].date(), lang)
text += "\n\n" + get_lang.get_string(lang, "already_voted").format(
stars, date)
if extract[3] and extract[4] is not None:
reply_markup = keyboards.change_vote_kb(extract[0], lang)
else:
text += "\n\n"
text += get_lang.get_string(lang, "vote_from_one_to_five")
reply_markup = keyboards.vote_group_kb(extract[0], lang)
update.message.reply_text(text=text, reply_markup=reply_markup)
def donate_button(bot, query):
addresses = config.DONATE_ADDRESSES
if addresses is not None:
query.answer()
lang = utils.get_db_lang(query.from_user.id)
reply_markup = keyboards.back_main_private_help_kb(lang)
pre_text = get_lang.get_string(lang, "donate_intro")
text = "{}<code>{}</code>".format(pre_text, addresses)
try:
query.edit_message_text(text=text,
reply_markup=reply_markup,
parse_mode='HTML')
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
else:
lang = utils.get_db_lang(query.from_user.id)
text = get_lang.get_string(lang, "something_went_wrong")
query.answer(text=text)
reply_markup = keyboards.help_kb(lang)
try:
query.message.edit_reply_markup(reply_markup=reply_markup)
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
def filter_by_category(bot, query):
lang = utils.get_db_lang(query.from_user.id)
text = get_lang.get_string(lang, "choose_category_to_filter")
params = query.data.split(":")
back_callback = ":".join(params[1:])
params[2] = '1' # change page to first page
params = params[1:] # first removed
base = ":".join(params)
query.answer()
reply_markup = keyboards.filter_by_category_leaderboard_kb(
lang, base, back_callback)
try:
query.edit_message_text(text=text, reply_markup=reply_markup)
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
def lbpage_igl_private(bot, query, page, group_id_buttons):
lang = utils.get_db_lang(query.from_user.id)
leaderboard = leaderboards.GroupLeaderboard(lang=lang,
page=int(page),
group_id=group_id_buttons)
query_db = "SELECT username FROM supergroups_ref WHERE group_id = %s LIMIT 1"
extract = database.query_r(query_db, group_id_buttons, one=True)
result = leaderboard.build_page(group_username=extract[0],
only_admins=False)
try:
query.edit_message_text(text=result[0],
reply_markup=result[1],
parse_mode=ParseMode.MARKDOWN,
disable_notification=True)
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
def groupleaderboard_private_direct_link(bot, update, group_id):
user_id = update.message.from_user.id
lang = utils.get_db_lang(user_id)
page = 1
update.effective_chat.send_action('typing')
query_db = "SELECT username FROM supergroups_ref WHERE group_id = %s LIMIT 1"
extract = database.query_r(query_db, group_id, one=True)
leaderboard = leaderboards.GroupLeaderboard(lang=lang,
page=page,
group_id=group_id)
result = leaderboard.build_page(group_username=extract[0],
only_admins=False)
update.message.reply_text(text=result[0],
reply_markup=result[1],
parse_mode='MARKDOWN',
disable_notification=True)
def lbpage_private(bot, query, lb_type, page, region, category):
lang = utils.get_db_lang(query.from_user.id)
if lb_type == leaderboards.Leaderboard.VOTES:
leaderboard = leaderboards.VotesLeaderboard(lang, region, int(page),
category)
elif lb_type == leaderboards.Leaderboard.MESSAGES:
leaderboard = leaderboards.MessagesLeaderboard(lang, region, int(page),
category)
elif lb_type == leaderboards.Leaderboard.MEMBERS:
leaderboard = leaderboards.MembersLeaderboard(lang, region, int(page),
category)
result = leaderboard.build_page()
try:
query.edit_message_text(text=result[0],
reply_markup=result[1],
parse_mode=ParseMode.MARKDOWN,
disable_web_page_preview=True)
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
def send_vote_by_link(bot, update, first_arg):
group_id = first_arg.lower().replace("vote", "")
user_id = update.message.from_user.id
lang = utils.get_db_lang(user_id)
query = """
SELECT s.group_id, s_ref.username, s_ref.title, v.vote, v.vote_date
FROM supergroups AS s
LEFT OUTER JOIN supergroups_ref AS s_ref -- right so None it's returned if not there
ON s_ref.group_id = s.group_id
LEFT OUTER JOIN votes AS v
ON v.group_id = s.group_id
AND v.user_id = %s
WHERE s.group_id = %s
"""
extract = database.query_r(query, user_id, group_id, one=True)
if extract is None:
# the group does not exist otherwise anything is returned and if None is NULL
text = get_lang.get_string(lang, "cant_vote_this")
update.message.reply_text(text=text)
return
text = get_lang.get_string(lang, "vote_this_group").format(
extract[0], extract[1], extract[2])
if extract[3] is not None and extract[4] is not None:
stars = emojis.STAR * extract[3]
date = utils.formatted_date_l(extract[4].date(), lang)
text += "\n\n" + get_lang.get_string(lang, "already_voted").format(
stars, date)
if extract[3] and extract[4] is not None:
reply_markup = keyboards.change_vote_kb(extract[0], lang)
else:
text += "\n\n"
text += get_lang.get_string(lang, "vote_from_one_to_five")
reply_markup = keyboards.vote_group_kb(extract[0], lang)
update.message.reply_text(text=text, reply_markup=reply_markup)
def unrecognized_button(self):
user_id = self.update.message.from_user.id
lang = utils.get_db_lang(user_id)
text = get_lang.get_string(lang, "unrecognized_button")
reply_markup = keyboards.default_regular_buttons_kb(lang)
self.update.message.reply_text(text=text, reply_markup=reply_markup)
def reply_feedback(self, bot, update):
first = None
try:
lang = utils.get_db_lang(self.feedback_from.id)
if update.message.text:
first = bot.sendMessage(chat_id=self.feedback_from.id,
text=update.message.text)
elif update.message.voice:
media = update.message.voice.file_id
duration = update.message.voice.duration
caption = update.message.caption_html if update.message.caption else None
first = bot.sendVoice(chat_id=self.feedback_from.id,
voice=media,
duration=duration,
caption=caption,
parse_mode='HTML')
elif update.message.photo:
media = update.message.photo[-1].file_id
caption = update.message.caption_html if update.message.caption else None
first = bot.sendPhoto(chat_id=self.feedback_from.id,
photo=media,
caption=caption,
parse_mode='HTML')
elif update.message.sticker:
media = update.message.sticker.file_id
first = bot.sendSticker(chat_id=self.feedback_from.id,
sticker=media)
elif update.message.document:
media = update.message.document.file_id
filename = update.message.document.file_name
caption = update.message.caption_html if update.message.caption else None
first = bot.sendDocument(chat_id=self.feedback_from.id,
document=media,
filename=filename,
caption=caption,
parse_mode='HTML')
elif update.message.audio:
media = update.message.audio.file_id
duration = update.message.audio.duration
performer = update.message.audio.performer
title = update.message.audio.title
caption = update.message.caption_html if update.message.caption else None
first = bot.sendAudio(chat_id=self.feedback_from.id,
audio=media,
duration=duration,
performer=performer,
title=title,
caption=caption,
parse_mode='HTML')
elif update.message.video:
media = update.message.video.file_id
caption = update.message.caption_html if update.message.caption else None
duration = update.message.video.duration
first = bot.sendVideo(chat_id=self.feedback_from.id,
video=media,
duration=duration,
caption=caption,
parse_mode='HTML')
bot.sendMessage(chat_id=self.feedback_from.id,
text=get_lang.get_string(lang, "from_developer"),
parse_mode='HTML',
reply_to_message_id=first.message_id,
reply_markup=keyboards.feedback_reply_kb(lang))
confirm = "sent to #id_{}".format(self.feedback_from.id)
bot.sendMessage(chat_id=config.FOUNDER,
text=confirm,
disable_notification=True)
except Unauthorized as e:
reason = "Message not sent.\n\n<code>{}</code>".format(e.message)
update.message.reply_text(reason, quote=True, parse_mode='HTML')
def groupleaderboard_private(bot, update, args):
user_id = update.message.from_user.id
lang = utils.get_db_lang(user_id)
if len(args) > 2 or len(args) == 0:
text = get_lang.get_string(lang,
"error_param_group_leaderboard_private")
update.message.reply_text(text, parse_mode="HTML")
return
if len(args) == 2 and (any([arg.startswith("p=")
for arg in args])) is False:
text = get_lang.get_string(lang,
"error_param_group_leaderboard_private")
update.message.reply_text(text, parse_mode="HTML")
return
page = 1
for arg in args:
if arg.startswith('p='):
try:
page = int(arg.replace('p=', ''))
except ValueError:
update.message.reply_text(text=get_lang.get_string(
lang, "error_param_group_leaderboard_private"),
parse_mode='HTML')
return
if page <= 0:
update.message.reply_text(text=get_lang.get_string(
lang, "error_param_group_leaderboard_private"),
parse_mode='HTML')
else:
group_username = arg
if group_username.startswith("@"):
group_username = group_username.replace("@", "")
update.effective_chat.send_action('typing')
query = "SELECT group_id FROM supergroups_ref WHERE LOWER(username) = LOWER(%s)"
extract = database.query_r(query, group_username)
if len(extract) > 1:
print("error too many")
return
if len(extract) == 0:
# the group does not exist otherwise anything is returned and if None is NULL
text = get_lang.get_string(lang, "cant_check_this").format(
html.escape(group_username))
update.message.reply_text(text=text)
return
group_id = extract[0][0]
leaderboard = leaderboards.GroupLeaderboard(lang=lang,
page=page,
group_id=group_id)
result = leaderboard.build_page(group_username=group_username,
only_admins=False)
update.message.reply_text(text=result[0],
reply_markup=result[1],
parse_mode='MARKDOWN',
disable_notification=True)
def current_page(bot, query):
lang = utils.get_db_lang(query.from_user.id)
query.answer(get_lang.get_string(lang, "already_this_page"),
show_alert=True)
def set_vote(bot, query):
lang = utils.get_db_lang(query.from_user.id)
vote = query.data.split(":")[1]
group_id = query.data.split(":")[2]
if vote == "cancel":
text = get_lang.get_string(lang, "canceled")
query.answer(text=text, show_alert=True)
text = utils.vote_intro(group_id, lang)
# check if it's need to add the "already_voted"
query_db = "SELECT vote, vote_date FROM votes WHERE user_id = %s AND group_id = %s"
extract = database.query_r(query_db,
query.from_user.id,
group_id,
one=True)
if extract is not None:
stars = emojis.STAR * extract[0]
date = utils.formatted_date_l(extract[1].date(), lang)
text += "\n\n" + get_lang.get_string(lang, "already_voted").format(
stars, date)
try:
query.edit_message_text(text=text,
reply_markup=keyboards.change_vote_kb(
group_id, lang, vote_first_time=True))
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
return
vote = int(vote)
alert = ""
query_db = """
INSERT INTO votes
(user_id, group_id, vote, vote_date)
VALUES (%s, %s, %s, now())
ON CONFLICT DO NOTHING
RETURNING*
"""
extract = database.query_wr(query_db,
query.from_user.id,
group_id,
vote,
one=True)
if extract is not None:
alert = get_lang.get_string(lang, "registered_vote")
else:
query_db = """
UPDATE votes
SET
vote = %s,
vote_date = now()
WHERE
user_id = %s AND
group_id = %s
"""
database.query_w(query_db, vote, query.from_user.id, group_id)
alert = get_lang.get_string(lang, "updated_vote")
query.answer(text=alert, show_alert=True)
text = "{}\n\n{}\n{}".format(utils.vote_intro(group_id, lang), alert,
emojis.STAR * vote)
try:
query.edit_message_text(text=text,
reply_markup=keyboards.change_vote_kb(
group_id, lang))
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
def settings_private(bot, update):
lang = utils.get_db_lang(update.message.from_user.id)
reply_markup = keyboards.main_private_settings_kb(lang)
text = get_lang.get_string(lang, "private_settings")
update.message.reply_text(text=text, reply_markup=reply_markup)
def aboutyou(bot, update):
user_id = update.message.from_user.id
# query = """
# WITH tleft AS (
# SELECT main.user_id, u.lang, main.num_msgs, main.num_grps, main.rnk
# FROM (
# SELECT
# user_id,
# num_grps,
# num_msgs,
# DENSE_RANK() OVER(ORDER BY num_msgs DESC, num_grps DESC, user_id DESC) rnk
# FROM (
# SELECT
# user_id,
# COUNT(distinct group_id) AS num_grps,
# COUNT(*) AS num_msgs
# FROM messages
# WHERE message_date > date_trunc('week', now())
# GROUP BY user_id
# ) AS sub
# ) AS main
# LEFT OUTER JOIN users AS u
# USING (user_id)
# WHERE u.weekly_own_digest = TRUE AND user_id = %s
# AND bot_blocked = FALSE
# )
# , tright AS (
# SELECT main.user_id, main.group_id, s_ref.title, s_ref.username, main.m_per_group, main.pos
# FROM (
# SELECT user_id, group_id, COUNT(user_id) AS m_per_group,
# ROW_NUMBER() OVER (
# PARTITION BY group_id
# ORDER BY COUNT(group_id) DESC
# ) AS pos
# FROM messages
# WHERE message_date > date_trunc('week', now()) AND user_id = %s
# GROUP BY group_id, user_id
# ) AS main
# LEFT OUTER JOIN supergroups_ref AS s_ref
# USING (group_id)
# ORDER BY m_per_group DESC
# )
# SELECT l.user_id, l.lang, l.num_msgs, l.num_grps, l.rnk, r.title, r.username, r.m_per_group, r.pos
# FROM tleft AS l
# INNER JOIN tright AS r
# USING (user_id)
# """
#######################
# WARNING!!!! #
#######################
# No more using the query to the db, but using the scheduled cache.
# by the way the result is returned in the very same form
# so it can be changed anytime
# FOLLOWING LINES ARE COMMENTED TO NOT EXECUTE THE QUERY
#extract = database.query_r(query, user_id, user_id)
#extract = cache_users_stats.group_extract(extract)[0]
user_cache, latest_update = cache_users_stats.get_cached_user(user_id)
lang = utils.get_db_lang(user_id)
if user_cache is None:
text = get_lang.get_string(lang, "you_inactive_this_week")
else:
text = get_lang.get_string(lang, "this_week_you_sent_this") + "\n\n"
groups = user_cache[1]
for group in groups:
title = group[0]
username = group[1]
m_per_group = group[2]
pos_per_group = group[3]
text += get_lang.get_string(lang,
"messages_in_groups_position").format(
utils.sep_l(m_per_group, lang),
username,
utils.sep_l(pos_per_group, lang))
# global stats
text += "\n" + get_lang.get_string(
lang, "you_globally_this_week").format(
utils.sep_l(user_cache[0][2], lang),
utils.sep_l(user_cache[0][3], lang),
utils.sep_l(user_cache[0][4], lang))
text += "\n\n{}: {}.".format(
utils.get_lang.get_string(lang, "latest_update"),
utils.round_seconds(int(time.time() - latest_update), lang))
utils.send_message_long(bot, chat_id=user_id, text=text)
def send_groups_working(bot, update):
lang = utils.get_db_lang(update.message.from_user.id)
text = get_lang.get_string(lang, "groups_working")
update.message.reply_text(text=text, parse_mode='HTML')
def feedback(bot, update):
sender_id = update.message.from_user.id
lang = utils.get_db_lang(sender_id)
text = constants.FEEDBACK_INV_CHAR
text += get_lang.get_string(lang, "feedback_message")
update.message.reply_text(text=text)
def do_not_receive_feedback(self, bot, update):
sender_id = self.feedback_from.id
lang = utils.get_db_lang(sender_id)
update.message.reply_text(get_lang.get_string(lang, "feedback_flood"),
quote=True)
def start_help_buttons(bot, update):
lang = utils.get_db_lang(update.message.from_user.id)
text = get_lang.get_string(lang, "hello")
reply_markup = keyboards.default_regular_buttons_kb(lang)
update.message.reply_text(text=text, reply_markup=reply_markup)
