def choose_lang(bot, query):
lang = query.data.replace("set_group_lang_", "")
text = get_lang.get_string(lang, "choose_group_lang")
reply_markup = keyboards.select_group_lang_kb(lang)
query.answer()
query_db = "UPDATE supergroups SET lang = %s WHERE group_id = %s"
database.query_w(query_db, lang, query.message.chat.id)
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 add_supergroup_ref(bot, update):
query = """INSERT INTO
supergroups_ref(group_id, title, username, message_date)
VALUES (%s, %s, %s, %s)
ON CONFLICT (group_id) DO
UPDATE SET title = %s, username = %s, message_date = %s
WHERE supergroups_ref.group_id = %s"""
database.query_w(query, update.message.chat.id, update.message.chat.title,
update.message.chat.username, update.message.date,
update.message.chat.title, update.message.chat.username,
update.message.date, update.message.chat.id)
def change_group_category(bot, query):
query_db = "SELECT lang, category FROM supergroups WHERE group_id = %s"
lang = database.query_r(query_db, query.message.chat.id, one=True)[0]
category = query.data.split(":")[1]
query.answer()
reply_markup = keyboards.group_categories_kb(lang, category)
try:
query_db = "UPDATE supergroups SET category = %s WHERE group_id = %s"
database.query_w(query_db, category, query.message.chat.id)
query.message.edit_reply_markup(reply_markup=reply_markup)
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
def set_private_lang(bot, query):
lang = query.data.replace("set_private_lang_", "")
query_db = "UPDATE users SET lang = %s WHERE user_id = %s"
database.query_w(query_db, lang, query.from_user.id)
query.answer()
try:
query.message.edit_reply_markup(
reply_markup=keyboards.private_language_kb(lang))
except TelegramError as e:
if str(e) != "Message is not modified": print(e)
bot.sendMessage(chat_id=query.from_user.id,
text=get_lang.get_string(lang, "updating_buttons"),
reply_markup=keyboards.default_regular_buttons_kb(lang))
def add_user_db(bot, update):
m = update.message
guessed_lang = utils.guessed_user_lang(bot, update)
query = """INSERT INTO users(user_id, lang, region, tg_lang, message_date)
VALUES (%s, %s, %s, %s, %s)
ON CONFLICT (user_id) DO
UPDATE SET bot_blocked = FALSE, tg_lang = COALESCE(%s, users.tg_lang), message_date = %s
WHERE users.user_id = %s"""
database.query_w(query, m.from_user.id, guessed_lang, guessed_lang,
m.from_user.language_code, m.date,
m.from_user.language_code, m.date, m.from_user.id)
def unban_group(bot, update, args):
if len(args) != 1:
update.message.reply_text("1 args as id")
return
group_id = args[0]
query = """
UPDATE supergroups
SET
banned_on = NULL,
banned_until = NULL,
ban_reason = NULL
WHERE group_id = %s
"""
database.query_w(query, group_id)
update.message.reply_text("unbanned", quote=True)
def send_one_by_one(bot, job):
user_id = job.context[0]
message = job.context[1]
reply_markup = job.context[2]
try:
utils.send_message_long(bot,
chat_id=user_id,
text=message,
reply_markup=reply_markup,
disable_notification=True)
except Unauthorized:
query = "UPDATE users SET bot_blocked = TRUE WHERE user_id = %s"
database.query_w(query, user_id)
except Exception as e:
print("{} exception is send_one_by_one private own digest".format(e))
def send_one_by_one_weekly_group_digest(bot, job):
group_id = job.context[0]
message = job.context[1]
reply_markup = job.context[2]
try:
bot.send_message(
chat_id=group_id,
text=message,
reply_markup=reply_markup,
parse_mode='HTML',
disable_notification=True)
except Unauthorized:
query = "UPDATE supergroups SET bot_inside = FALSE WHERE group_id = %s"
database.query_w(query, group_id)
except Exception as e:
print("{} exception is send_one_by_one group digest".format(e))
def leave_banned_group(bot, update):
query_db = "SELECT lang, banned_until, ban_reason FROM supergroups WHERE group_id = %s"
extract = database.query_r(query_db, update.message.chat.id, one=True)
lang = extract[0]
banned_until = extract[1]
reason = extract[2]
shown_reason = html.escape(
reason) if reason is not None else get_lang.get_string(
lang, "not_specified")
shown_reason = "<code>{}</code>".format(shown_reason)
text = get_lang.get_string(lang, "banned_until_leave").format(
utils.formatted_datetime_l(banned_until.replace(microsecond=0), lang),
shown_reason)
update.message.reply_text(text=text, quote=False, parse_mode='HTML')
bot.leaveChat(update.message.chat.id)
query = "UPDATE supergroups SET bot_inside = FALSE WHERE group_id = %s"
database.query_w(query, update.message.chat.id)
def send_chat_action_inactive_group(bot, job):
errors = [
"Forbidden: bot was kicked from the supergroup chat",
"Forbidden: bot is not a member of the supergroup chat"
]
group_id = job.context[0]
try:
bot.sendChatAction(chat_id=group_id, action='typing')
except Exception as e:
if e in errors:
print(e)
print('right usage in clean_db inactive groups')
query = "UPDATE supergroups SET bot_inside=FALSE WHERE group_id=%s"
database.query_w(query, group_id)
else:
print(e)
print("cleandb inactive groups")
def add_user_ref(bot, update):
query = """INSERT INTO
users_ref(user_id, name, last_name, username, tg_lang, message_date)
VALUES (%s, %s, %s, %s, %s, %s)
ON CONFLICT (user_id) DO
UPDATE SET name = %s, last_name = %s, username = %s,
tg_lang = COALESCE(%s, users_ref.tg_lang), message_date = %s
WHERE users_ref.user_id = %s"""
database.query_w(query, update.message.from_user.id,
update.message.from_user.first_name,
update.message.from_user.last_name,
update.message.from_user.username,
update.message.from_user.language_code,
update.message.date, update.message.from_user.first_name,
update.message.from_user.last_name,
update.message.from_user.username,
update.message.from_user.language_code,
update.message.date, update.message.from_user.id)
def leave_unsupported_chat(bot, update):
if update.message.chat.type == "group" or (
update.message.chat.type == "supergroup"
and update.message.chat.username is None):
query = "SELECT lang FROM supergroups WHERE group_id = %s"
extract = database.query_r(query, update.message.chat.id, one=True)
if extract is None:
lang = 'en'
else:
lang = extract[0]
text = get_lang.get_string(lang, "unsupported_chat")
text += utils.text_mention_creator(bot, update.message.chat.id)
update.message.reply_text(text=text, quote=False, parse_mode='HTML')
bot.leaveChat(update.message.chat.id)
query = "UPDATE supergroups SET bot_inside = FALSE WHERE group_id = %s"
database.query_w(query, update.message.chat.id)
return True
def ban_group(bot, update, args):
if len(args) < 3:
text = "specify id for days\nexample: -34545322 for 30 (optional: for too much spam)"
update.message.reply_text(text)
return
params = " ".join(args).split(" for ")
group_id = params[0]
days = int(params[1])
try:
reason = params[2]
except IndexError:
reason = None
query = """
UPDATE supergroups
SET
banned_on = now(),
banned_until = now() + interval '%s days',
ban_reason = %s
WHERE group_id = %s
RETURNING lang, banned_until
"""
extract = database.query_wr(query, days, reason, group_id, one=True)
lang = extract[0]
banned_until = extract[1]
shown_reason = html.escape(
reason) if reason is not None else get_lang.get_string(
lang, "not_specified")
shown_reason = "<code>{}</code>".format(shown_reason)
text = get_lang.get_string(lang, "banned_until_leave").format(
utils.formatted_datetime_l(banned_until.replace(microsecond=0), lang),
shown_reason)
text += utils.text_mention_creator(bot, group_id)
try:
bot.send_message(chat_id=group_id, text=text, parse_mode='HTML')
bot.leaveChat(group_id)
except Unauthorized as e:
update.message.reply_text(e.message)
query = "UPDATE supergroups SET bot_inside = FALSE WHERE group_id = %s"
database.query_w(query, group_id)
update.message.reply_text("Done!")
def del_messages_from_db(self):
"""
Delete from the database all the messages sent during
the interval of the key
"""
query = """
DELETE FROM messages
WHERE (msg_id, group_id) IN (
SELECT msg_id, group_id
FROM messages
WHERE
user_id = %s
AND group_id = %s
AND message_date >= to_timestamp(%s)
ORDER BY message_date DESC
LIMIT %s
)
"""
db.query_w(
query,
self.user_id,
self.group_id,
self.get_time_key_started(),
(self.limit-1))
def handle_one_by_one(bot, job):
group_id = job.context
try:
info = bot.getChat(group_id)
members = bot.getChatMembersCount(group_id)
query = """
INSERT INTO members(group_id, amount, updated_date)
VALUES(%s, %s, now())
"""
database.query_w(query, group_id, members)
query = """
INSERT INTO
supergroups_ref(group_id, title, username)
VALUES (%s, %s, %s)
ON CONFLICT (group_id) DO
UPDATE SET title = %s, username = COALESCE(%s, supergroups_ref.username)
WHERE supergroups_ref.group_id = %s"""
database.query_w(query, group_id, info.title, info.username,
info.title, info.username, group_id)
except Unauthorized:
query = """
UPDATE supergroups
SET bot_inside = FALSE
WHERE group_id = %s
"""
database.query_w(query, group_id)
except BadRequest as e:
if str(e) == "Chat not found":
query = """
UPDATE supergroups
SET bot_inside = FALSE
WHERE group_id = %s
"""
database.query_w(query, group_id)
else:
print("{} in memberslog BadRequest: group_id: {}".format(
e, group_id))
except Exception as e:
print("{} in memberslog: group_id: {}".format(e, group_id))
def clean_db(bot, job):
query = "DELETE FROM messages WHERE message_date < now() - interval %s"
database.query_w(query, CLEAN_INTERVAL)
query = "DELETE FROM members WHERE updated_date < now() - interval %s"
database.query_w(query, CLEAN_INTERVAL)
def add_message_db(bot, update):
m = update.message
query = "INSERT INTO messages(msg_id, group_id, user_id, message_date) VALUES (%s, %s, %s, %s)"
database.query_w(query, m.message_id, m.chat.id, m.from_user.id, m.date)
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)