def update_comments(bot, channel_id, msg_id):
# update comments in channel
comment_id = helper_database.get_comment_id(channel_id, msg_id)
config = helper_database.get_channel_config(channel_id)
if config is None:
return
channel_lang = config[1]
mode = config[2]
recent = config[3]
records = helper_database.get_recent_records(channel_id, msg_id, recent)
# Prepare Keyboard
motd_keyboard = [[
InlineKeyboardButton(
helper_global.value("add_comment",
"Add Comment",
lang=channel_lang),
url="http://telegram.me/%s?start=add_%d_%d" %
(helper_global.value('bot_username', ''), channel_id, msg_id)),
InlineKeyboardButton(
helper_global.value("show_all_comments",
"Show All",
lang=channel_lang),
url="http://telegram.me/%s?start=show_%s_%d" %
(helper_global.value('bot_username', ''), channel_id, msg_id))
]]
motd_markup = InlineKeyboardMarkup(motd_keyboard)
bot.edit_message_text(text=helper_global.records_to_str(
records, channel_lang),
chat_id=channel_id,
message_id=comment_id,
parse_mode=telegram.ParseMode.HTML,
reply_markup=motd_markup)
def update_comments(bot, channel_id, msg_id, update_mode):
logger = Logger.logger
config = helper_database.get_channel_config(channel_id)
if config is None:
return
channel_lang = config[1]
mode = config[2]
recent = config[3]
logger.msg(
{
"channel_id": channel_id,
"msg_id": msg_id,
"update_mode": update_mode
},
tag="private",
log_level=80)
# update comments in channel
comment_id = helper_database.get_comment_id(channel_id, msg_id)
if comment_id is None:
# If no comment message, just update Like buttons
buttons = helper_database.get_button_options(channel_id, msg_id)
stat = helper_database.get_reaction_stat(channel_id, msg_id)
# Prepare Keyboard
motd_keyboard = [[
InlineKeyboardButton(value +
(" (%d)" % stat[idx] if idx in stat else ""),
callback_data="like,%s,%s,%d" %
(channel_id, msg_id, idx))
for idx, value in enumerate(buttons)
]] + [[
InlineKeyboardButton(
helper_global.value(
"add_comment", "Add Comment", lang=channel_lang),
url="http://telegram.me/%s?start=add_%d_%d" %
(helper_global.value('bot_username', ''), channel_id, msg_id)),
InlineKeyboardButton(
helper_global.value(
"show_all_comments", "Show All", lang=channel_lang),
url="http://telegram.me/%s?start=show_%s_%d" %
(helper_global.value('bot_username', ''), channel_id, msg_id))
]]
motd_markup = InlineKeyboardMarkup(motd_keyboard)
bot.edit_message_reply_markup(chat_id=channel_id,
message_id=msg_id,
reply_markup=motd_markup)
return
# Otherwise
# Update Like buttons
if update_mode == 0:
buttons = helper_database.get_button_options(channel_id, msg_id)
stat = helper_database.get_reaction_stat(channel_id, msg_id)
# Prepare Keyboard
motd_keyboard = [[
InlineKeyboardButton(
value + (" (%d)" % stat[idx] if idx in stat else ""),
callback_data="like,%s,%s,%d" % (channel_id, msg_id, idx))
for idx, value in enumerate(buttons)
]]
motd_markup = InlineKeyboardMarkup(motd_keyboard)
bot.edit_message_reply_markup(chat_id=channel_id,
message_id=msg_id,
reply_markup=motd_markup)
return
# Update comment message
records = helper_database.get_recent_records(channel_id, msg_id, recent)
# Prepare Keyboard
motd_keyboard = [[
InlineKeyboardButton(
helper_global.value("add_comment",
"Add Comment",
lang=channel_lang),
url="http://telegram.me/%s?start=add_%d_%d" %
(helper_global.value('bot_username', ''), channel_id, msg_id)),
InlineKeyboardButton(
helper_global.value("show_all_comments",
"Show All",
lang=channel_lang),
url="http://telegram.me/%s?start=show_%s_%d" %
(helper_global.value('bot_username', ''), channel_id, msg_id))
]]
motd_markup = InlineKeyboardMarkup(motd_keyboard)
bot.edit_message_text(text=helper_global.records_to_str(
records, channel_lang),
chat_id=channel_id,
message_id=comment_id,
parse_mode=telegram.ParseMode.HTML,
reply_markup=motd_markup)
def start(bot, update, args):
logger = Logger.logger
if args is None or len(args) == 0:
chat_id = update.message.chat_id
logger.msg({"user_id": chat_id}, tag="start", log_level=80)
helper_global.send_intro_template(bot, chat_id,
helper_const.DEFAULT_LANG, "start",
"start_cmd_text")
return
params = args[0].split("_")
channel_id = int(params[1])
msg_id = int(params[2])
chat_id = update.message.chat_id
logger.msg({"user_id": chat_id, "args": args}, tag="start", log_level=90)
if chat_id < 0:
return
config = helper_database.get_channel_config(channel_id)
if config is None:
return
channel_lang = config[1]
recent, username = config[3], config[4]
if helper_database.check_ban(channel_id, chat_id):
bot.send_message(chat_id=update.message.chat_id,
text=helper_global.value("banned_prompt",
"You are banned.",
lang=channel_lang))
return
if params[0] == "add":
helper_global.assign(
str(chat_id) + "_status", params[1] + "," + params[2])
motd_keyboard = [[
InlineKeyboardButton(
helper_global.value("reply_to", "Reply", lang=channel_lang) +
"...",
switch_inline_query_current_chat=" ")
]]
motd_markup = InlineKeyboardMarkup(motd_keyboard)
comment_id = helper_database.get_comment_id(channel_id, msg_id)
suffix = ""
if username is not None:
if comment_id is not None:
suffix = "\n" + helper_global.value(
"target_comment", "", lang=channel_lang
) + "https://t.me/%s/%d" % (username, comment_id)
bot.send_message(
chat_id=update.message.chat_id,
text=helper_global.value(
"start_comment_mode", "", lang=channel_lang) + "\n" +
helper_global.value("target_message", "", lang=channel_lang) +
"https://t.me/%s/%d" % (username, msg_id) + suffix,
reply_markup=motd_markup)
else:
link_id = abs(channel_id) % 10000000000
if comment_id is not None:
suffix = "\n" + helper_global.value(
"target_comment", "", lang=channel_lang
) + "https://t.me/%d/%d" % (link_id, comment_id)
bot.send_message(
chat_id=update.message.chat_id,
text=helper_global.value(
"start_comment_mode", "", lang=channel_lang) + "\n" +
helper_global.value("target_message", "", lang=channel_lang) +
"https://t.me/c/%d/%d" % (link_id, msg_id) + suffix,
reply_markup=motd_markup)
elif params[0] == "show":
offset = 0
channel_username = config[4]
records = helper_database.get_recent_records(channel_id, msg_id,
recent, offset)
# Prepare Keyboard
msg_buttons = helper_global.records_to_buttons(records, channel_id,
msg_id)
motd_keyboard = msg_buttons + [[
InlineKeyboardButton(
helper_global.value(
"prev_page", "Prev Page", lang=channel_lang),
callback_data="msg,%d,%d,%d,%d,%d" %
(channel_id, msg_id, recent, offset + 1, chat_id)),
InlineKeyboardButton(
helper_global.value(
"next_page", "Next Page", lang=channel_lang),
callback_data="msg,%d,%d,%d,%d,%d" %
(channel_id, msg_id, recent, offset - 1, chat_id))
]]
motd_markup = InlineKeyboardMarkup(motd_keyboard)
prompt_text = helper_global.value("comment_header",
"",
lang=channel_lang)
if channel_username is not None and len(channel_username) > 0:
prompt_text = "https://t.me/%s/%a\n" % (channel_username,
msg_id) + prompt_text
bot.send_message(chat_id=update.message.chat_id,
text=prompt_text,
parse_mode=telegram.ParseMode.HTML,
reply_markup=motd_markup)
def private_msg(bot, update):
logger = Logger.logger
message = update.edited_message if update.edited_message else update.message
chat_id = message.chat_id
args = helper_global.value(str(chat_id) + "_status", "0,0")
logger.msg({
"user_id": chat_id,
"status": args
},
tag="private",
log_level=90)
params = args.split(",")
channel_id = int(params[0])
msg_id = int(params[1])
if channel_id == 0:
if msg_id == 1:
check_channel_message(bot, message)
return
# Check comment message
comment_exist = helper_database.check_reflect(channel_id, msg_id)
config = helper_database.get_channel_config(channel_id)
if config is None:
return
channel_lang = config[1]
recent, username, admin_id, notify = config[3], config[4], config[
5], config[6]
logger.msg(
{
"user_id": chat_id,
"channel_id": channel_id,
"msg_id": msg_id,
"action": "add comment"
},
tag="private",
log_level=90)
# For Auto Mode = 2
if not comment_exist:
logger.msg(
{
"user_id": chat_id,
"channel_id": channel_id,
"msg_id": msg_id,
"action": "add comment area"
},
tag="private",
log_level=80)
comment_message = bot.send_photo(
chat_id=channel_id,
photo=open(sys.path[0] + "/default.jpg", "rb"),
caption=helper_global.value("comment_refreshing",
"Refreshing...",
lang=channel_lang),
reply_to_message_id=msg_id,
parse_mode=telegram.ParseMode.HTML).result()
helper_database.add_reflect(channel_id, msg_id,
comment_message.message_id)
#bot.edit_message_reply_markup(
# chat_id=channel_id,
# message_id=msg_id,
# reply_markup=None
#)
update_dirty_msg(channel_id, msg_id, update_mode=0)
result = add_record(bot, channel_id, msg_id, message)
# Update Dirty List
update_dirty_msg(channel_id, msg_id)
if notify == 1 and not int(chat_id) == int(admin_id):
logger.msg(
{
"user_id": chat_id,
"channel_id": channel_id,
"msg_id": msg_id,
"admin_id": admin_id,
"action": "notify channel owner"
},
tag="private",
log_level=80)
if username is not None:
suffix = ""
if comment_exist:
comment_id = helper_database.get_comment_id(channel_id, msg_id)
suffix = "\n" + helper_global.value(
"target_comment", "", lang=channel_lang
) + "https://t.me/%s/%d" % (username, comment_id)
bot.send_message(
chat_id=admin_id,
text=helper_global.value("new_comment_message",
"You have a new comment message.",
lang=channel_lang) + "\n" +
helper_global.value("target_message", "", lang=channel_lang) +
"https://t.me/%s/%d" % (username, msg_id) + suffix)
else:
link_id = abs(channel_id) % 10000000000
suffix = ""
if comment_exist:
comment_id = helper_database.get_comment_id(channel_id, msg_id)
suffix = "\n" + helper_global.value(
"target_comment", "", lang=channel_lang
) + "https://t.me/c/%d/%d" % (link_id, comment_id)
bot.send_message(
chat_id=admin_id,
text=helper_global.value("new_comment_message",
"You have a new comment message.",
lang=channel_lang) + "\n" +
helper_global.value("target_message", "", lang=channel_lang) +
"https://t.me/c/%d/%d" % (link_id, msg_id) + suffix)
if result == 0:
bot.send_message(chat_id=chat_id,
text=helper_global.value("comment_success",
"Success!",
lang=channel_lang))
elif result == 1:
bot.send_message(chat_id=chat_id,
text=helper_global.value("comment_edit_success",
"Success!",
lang=channel_lang))
def add_record(bot, channel_id, msg_id, message):
logger = Logger.logger
ori_msg_id = message.message_id
user = message.from_user
username = user.username
user_id = user.id
name = user.first_name
if user.last_name:
name += " " + user.last_name
date = message.date.strftime("%Y-%m-%d %H:%M:%S")
msg_type = "text"
msg_content = ""
media_id = ""
if message.text:
msg_type = "text"
msg_content = message.text
elif message.sticker:
msg_type = 'sticker'
media_id = message.sticker.file_id
if message.sticker.emoji:
msg_content = message.sticker.emoji
elif message.photo:
msg_type = 'photo'
media_id = message.photo[-1].file_id
if message.caption:
msg_content = message.caption
elif message.video:
msg_type = 'video'
media_id = message.video.file_id
if message.caption:
msg_content = message.caption
elif message.document:
msg_type = 'document'
media_id = message.document.file_id
if message.document.file_name:
msg_content = message.document.file_name
elif message.audio:
msg_type = 'audio'
media_id = message.audio.file_id
if message.audio.title:
msg_content = message.audio.title
elif message.voice:
msg_type = 'voice'
media_id = message.voice.file_id
msg_content = helper_global.parse_entity(msg_content, message.entities)
target_name = ""
if message.reply_markup and message.reply_markup.inline_keyboard:
keyboard = message.reply_markup.inline_keyboard
if len(keyboard) > 0 and len(keyboard[0]) > 0:
query = keyboard[0][0]
if query.callback_data:
args = query.callback_data.split(",")
if len(args) == 4 and args[0] == "notify":
target_channel_id = int(args[1])
target_msg_id = int(args[2])
target_row_id = args[3]
record = helper_database.get_record_by_rowid(target_row_id)
if len(record) > 0 and target_channel_id == int(
record[0][0]) and target_msg_id == int(
record[0][1]):
target_name = record[0][3]
target_user_id = record[0][8]
config = helper_database.get_channel_config(channel_id)
if config is None:
return
channel_lang, channel_username = config[1], config[4]
if channel_username is not None:
logger.msg(
{
"channel_id": channel_id,
"msg_id": msg_id,
"target_user": target_user_id,
"action": "notify reply"
},
tag="private",
log_level=80)
comment_id = helper_database.get_comment_id(
channel_id, target_msg_id)
suffix = ""
if comment_id is not None:
suffix = "\n" + helper_global.value(
"target_comment", "", lang=channel_lang
) + "https://t.me/%s/%d" % (channel_username,
comment_id)
bot.send_message(
chat_id=target_user_id,
text=helper_global.value(
"new_reply_message",
"You receive a reply message.",
lang=channel_lang) + "\n" +
helper_global.value(
"target_message", "", lang=channel_lang) +
"https://t.me/%s/%d" %
(channel_username, target_msg_id) + suffix)
else:
link_id = abs(channel_id) % 10000000000
comment_id = helper_database.get_comment_id(
channel_id, target_msg_id)
suffix = ""
if comment_id is not None:
suffix = "\n" + helper_global.value(
"target_comment", "", lang=channel_lang
) + "https://t.me/c/%d/%d" % (link_id,
comment_id)
bot.send_message(
chat_id=target_user_id,
text=helper_global.value(
"new_reply_message",
"You receive a reply message.",
lang=channel_lang) + "\n" +
helper_global.value(
"target_message", "", lang=channel_lang) +
"https://t.me/c/%d/%d" %
(link_id, target_msg_id) + suffix)
return helper_database.add_record(channel_id, msg_id, username, name,
msg_type, msg_content, media_id, date,
user_id, ori_msg_id, target_name)
def update_comments(bot, channel_id, msg_id, update_mode):
logger = Logger.logger
config = helper_database.get_channel_config(channel_id)
if config is None:
return
channel_lang = config[1]
mode = config[2]
recent = config[3]
logger.msg(
{
"channel_id": channel_id,
"msg_id": msg_id,
"update_mode": update_mode
},
tag="private",
log_level=80)
# update comments in channel
comment_id = helper_database.get_comment_id(channel_id, msg_id)
if comment_id is None:
# If no comment message, just update Like buttons
buttons = helper_database.get_button_options(channel_id, msg_id)
stat = helper_database.get_reaction_stat(channel_id, msg_id)
# Prepare Keyboard
motd_keyboard = [[
InlineKeyboardButton(value +
(" (%d)" % stat[idx] if idx in stat else ""),
callback_data="like,%s,%s,%d" %
(channel_id, msg_id, idx))
for idx, value in enumerate(buttons)
]] + [[
InlineKeyboardButton(
helper_global.value(
"add_comment", "Add Comment", lang=channel_lang),
url="http://telegram.me/%s?start=add_%d_%d" %
(helper_global.value('bot_username', ''), channel_id, msg_id)),
InlineKeyboardButton(
helper_global.value(
"show_all_comments", "Show All", lang=channel_lang),
url="http://telegram.me/%s?start=show_%s_%d" %
(helper_global.value('bot_username', ''), channel_id, msg_id))
]]
motd_markup = InlineKeyboardMarkup(motd_keyboard)
bot.edit_message_reply_markup(chat_id=channel_id,
message_id=msg_id,
reply_markup=motd_markup)
return
# Otherwise
# Update Like buttons
if update_mode == 0:
buttons = helper_database.get_button_options(channel_id, msg_id)
stat = helper_database.get_reaction_stat(channel_id, msg_id)
# Prepare Keyboard
motd_keyboard = [[
InlineKeyboardButton(
value + (" (%d)" % stat[idx] if idx in stat else ""),
callback_data="like,%s,%s,%d" % (channel_id, msg_id, idx))
for idx, value in enumerate(buttons)
]]
motd_markup = InlineKeyboardMarkup(motd_keyboard)
bot.edit_message_reply_markup(chat_id=channel_id,
message_id=msg_id,
reply_markup=motd_markup)
return
# Update comment message
records = helper_database.get_recent_records(channel_id, msg_id, recent)
# Prepare Keyboard
motd_keyboard = [[
InlineKeyboardButton(
helper_global.value("add_comment",
"Add Comment",
lang=channel_lang),
url="http://telegram.me/%s?start=add_%d_%d" %
(helper_global.value('bot_username', ''), channel_id, msg_id)),
InlineKeyboardButton(
helper_global.value("show_all_comments",
"Show All",
lang=channel_lang),
url="http://telegram.me/%s?start=show_%s_%d" %
(helper_global.value('bot_username', ''), channel_id, msg_id))
]]
motd_markup = InlineKeyboardMarkup(motd_keyboard)
rev_records = records[:]
rev_records.reverse()
scope = {"BOT_TOKEN": "", "FILES_GROUP": 0}
with open(sys.path[0] + "/helper_const.py", "r") as f:
lines = f.readlines()
for line in lines:
if line.strip().startswith("BOT_TOKEN") or line.strip().startswith(
"FILES_GROUP"):
# trusted file
exec(line, scope)
infos = []
render_as_text_records = []
for record in rev_records:
name = record[3]
ftype = "text" if record[4] == "text" else "unsupported"
if record[4] == "photo":
ftype = "image"
elif record[4] == "sticker":
ftype = "sticker"
content = record[5]
fid = record[6]
timestr = record[7]
uid = record[8]
reply_to = record[10]
url = ""
if fid != "":
ctx = f"https://api.telegram.org/bot{scope['BOT_TOKEN']}/getFile?file_id={fid}"
with urllib.request.urlopen(ctx) as resp:
result = resp.read()
url = "https://api.telegram.org/file/"
url += "bot" + scope["BOT_TOKEN"] + "/" + json.loads(
result)["result"]["file_path"]
info = {
"name": name,
"type": ftype,
"content": content,
"timeStr": timestr,
"uid": uid,
"url": url,
"replyTo": reply_to
}
infos.append(info)
if ftype == "text":
if len(render_as_text_records) < 5:
render_as_text_records.append(record)
else:
render_as_text_records.remove(render_as_text_records[0])
render_as_text_records.append(record)
else:
render_as_text_records = []
render_as_text_records.reverse()
infos = infos[0:len(infos) - len(render_as_text_records)]
remote = "http://127.0.0.1:6899/render/" + urllib.parse.quote(
json.dumps(infos), safe='')
with urllib.request.urlopen(remote) as resp:
fpath = json.loads(resp.read())["path"]
with open(fpath, "rb") as f:
photo_message = bot.send_photo(
chat_id=scope["FILES_GROUP"],
photo=f,
caption=helper_global.records_to_str(render_as_text_records,
channel_lang),
parse_mode=telegram.ParseMode.HTML).result()
photo = photo_message.photo[0]
comment_text = helper_global.records_to_str(
render_as_text_records, channel_lang)
media = telegram.InputMediaPhoto(
photo.file_id,
caption=comment_text,
parse_mode=telegram.ParseMode.HTML)
bot.edit_message_media(
# text=helper_global.records_to_str(render_as_text_records, channel_lang),
media=media,
chat_id=channel_id,
message_id=comment_id,
parse_mode=telegram.ParseMode.HTML,
reply_markup=motd_markup)