def join_fed(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
administrators = chat.get_administrators()
fed_id = sql.get_fed_id(chat.id)
if user.id not in SUDO_USERS:
for admin in administrators:
status = admin.status
if status == "creator":
print(admin)
if str(admin.user.id) != str(user.id):
update.effective_message.reply_text(
tld(chat.id, "common_group_creator_only"))
return
if fed_id:
message.reply_text(tld(chat.id, "feds_group_joined_fed"))
return
if args:
fedd = args[0]
print(fedd)
if sql.search_fed_by_id(fedd) is False:
message.reply_text(tld(chat.id, "feds_fedid_invalid"))
return
x = sql.chat_join_fed(fedd, chat.id)
if not x:
message.reply_text(tld(chat.id, "feds_join_unknown_err"))
return
message.reply_text(tld(chat.id, "feds_join_success"))
def log_user(update, context):
chat = update.effective_chat # type: Optional[Chat]
msg = update.effective_message # type: Optional[Message]
"""text = msg.text if msg.text else ""
uid = msg.from_user.id
uname = msg.from_user.name
print("{} | {} | {} | {}".format(text, uname, uid, chat.title))"""
fed_id = fedsql.get_fed_id(chat.id)
if fed_id:
user = update.effective_user
if user:
fban, fbanreason, fbantime = fedsql.get_fban_user(fed_id, user.id)
if fban:
send_message(
update.effective_message,
languages.tl(
update.effective_message,
"Pengguna ini dilarang di federasi saat ini!\nAlasan: `{}`"
).format(fbanreason),
parse_mode="markdown")
try:
context.bot.kick_chat_member(chat.id, user.id)
except Exception:
print("Fban: cannot ban this user")
sql.update_user(msg.from_user.id, msg.from_user.username, chat.id,
chat.title)
if msg.reply_to_message:
sql.update_user(msg.reply_to_message.from_user.id,
msg.reply_to_message.from_user.username, chat.id,
chat.title)
if msg.forward_from:
sql.update_user(msg.forward_from.id, msg.forward_from.username)
def fed_notif(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
fed_id = sql.get_fed_id(chat.id)
if not fed_id:
update.effective_message.reply_text(
"This group is not a part of any federation!")
return
if args:
if args[0] in ("yes", "on"):
sql.set_feds_setting(user.id, True)
msg.reply_text(
"Reporting Federation actions turned on! You will be notified for every fban/unfban via PM."
)
elif args[0] in ("no", "off"):
sql.set_feds_setting(user.id, False)
msg.reply_text(
"Reporting Federation actions turned off! You will be notified for every fban/unfban via PM."
)
else:
msg.reply_text("Please enter `yes`/`on`/`no`/`off`",
parse_mode="markdown")
else:
getreport = sql.user_feds_report(user.id)
msg.reply_text(
"Your current Federation report preferences: `{}`".format(
getreport),
parse_mode="markdown")
def user_join_fed(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
fed_id = sql.get_fed_id(chat.id)
if is_user_fed_owner(fed_id, user.id):
user_id = extract_user(msg, args)
if user_id:
user = bot.get_chat(user_id)
elif not msg.reply_to_message and not args:
user = msg.from_user
elif not msg.reply_to_message and (
not args or
(len(args) >= 1 and not args[0].startswith("@")
and not args[0].isdigit()
and not msg.parse_entities([MessageEntity.TEXT_MENTION]))):
msg.reply_text(tld(chat.id, "common_err_no_user"))
return
else:
LOGGER.warning('error')
getuser = sql.search_user_in_fed(fed_id, user_id)
fed_id = sql.get_fed_id(chat.id)
info = sql.get_fed_info(fed_id)
get_owner = eval(info['fusers'])['owner']
get_owner = bot.get_chat(get_owner).id
if user_id == get_owner:
update.effective_message.reply_text(
tld(chat.id, "feds_promote_owner"))
return
if getuser:
update.effective_message.reply_text(
tld(chat.id, "feds_promote_owner"))
return
if user_id == bot.id:
update.effective_message.reply_text(
tld(chat.id, "feds_promote_bot"))
return
res = sql.user_join_fed(fed_id, user_id)
if res:
update.effective_message.reply_text(
tld(chat.id, "feds_promote_success"))
else:
update.effective_message.reply_text("")
else:
update.effective_message.reply_text(tld(chat.id, "feds_owner_only"))
def get_frules(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
fed_id = sql.get_fed_id(chat.id)
if not fed_id:
update.effective_message.reply_text(
"This chat is not in any federation!")
return
rules = sql.get_frules(fed_id)
text = "*Rules in this fed:*\n\n"
text += rules
update.effective_message.reply_text(text, parse_mode=ParseMode.MARKDOWN)
return
def welcome_fed(bot, update):
chat = update.effective_chat
user = update.effective_user
fed_id = sql.get_fed_id(chat.id)
fban, fbanreason = sql.get_fban_user(fed_id, user.id)
if fban:
update.effective_message.reply_text(
"This user is banned in current federation! I will remove him.")
bot.kick_chat_member(chat.id, user.id)
return True
else:
return False
def fed_chat(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
fed_id = sql.get_fed_id(chat.id)
if not fed_id:
update.effective_message.reply_text(
tld(chat.id, "feds_group_not_in_fed"))
return
chat = update.effective_chat
info = sql.get_fed_info(fed_id)
text = tld(chat.id, "feds_group_part_of_fed")
text += "\n{} (ID: <code>{}</code>)".format(info['fname'], fed_id)
update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
def leave_fed(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
fed_id = sql.get_fed_id(chat.id)
fed_info = sql.get_fed_info(fed_id)
# administrators = chat.get_administrators().status
getuser = bot.get_chat_member(chat.id, user.id).status
if getuser in 'creator' or user.id in SUDO_USERS:
if sql.chat_leave_fed(chat.id) is True:
update.effective_message.reply_text(
tld(chat.id, "feds_leave_success").format(fed_info['fname']))
else:
update.effective_message.reply_text(
tld(chat.id, "feds_leave_not_joined"))
else:
update.effective_message.reply_text(
tld(chat.id, "common_group_creator_only"))
def user_demote_fed(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
fed_id = sql.get_fed_id(chat.id)
if is_user_fed_owner(fed_id, user.id):
msg = update.effective_message
user_id = extract_user(msg, args)
if user_id:
user = bot.get_chat(user_id)
elif not msg.reply_to_message and not args:
user = msg.from_user
elif not msg.reply_to_message and (
not args or
(len(args) >= 1 and not args[0].startswith("@")
and not args[0].isdigit()
and not msg.parse_entities([MessageEntity.TEXT_MENTION]))):
msg.reply_text(tld(chat.id, "common_err_no_user"))
return
else:
LOGGER.warning('error')
if user_id == bot.id:
update.effective_message.reply_text(tld(chat.id,
"feds_demote_bot"))
return
if sql.search_user_in_fed(fed_id, user_id) is False:
update.effective_message.reply_text(
tld(chat.id, "feds_demote_target_not_admin"))
return
res = sql.user_demote_fed(fed_id, user_id)
if res is True:
update.effective_message.reply_text(
tld(chat.id, "feds_demote_success"))
else:
update.effective_message.reply_text(
tld(chat.id, "feds_demote_failed"))
else:
update.effective_message.reply_text(tld(chat.id, "feds_owner_only"))
return
def fed_chats(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
fed_id = sql.get_fed_id(chat.id)
info = sql.get_fed_info(fed_id)
if not fed_id:
update.effective_message.reply_text(
"This group is not a part of any federation!")
return
if is_user_fed_admin(fed_id, user.id) is False:
update.effective_message.reply_text(
"Only federation admins can do this!")
return
getlist = sql.all_fed_chats(fed_id)
if len(getlist) == 0:
update.effective_message.reply_text(
"No users are fbanned from the federation {}".format(
info['fname']),
parse_mode=ParseMode.HTML)
return
text = "<b>Groups that have joined the federation {}:</b>\n".format(
info['fname'])
for chats in getlist:
chat_name = dispatcher.bot.getChat(chats).title
text += " • {} (<code>{}</code>)\n".format(chat_name, chats)
try:
update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
except Exception:
cleanr = re.compile('<.*?>')
cleantext = re.sub(cleanr, '', text)
with BytesIO(str.encode(cleantext)) as output:
output.name = "fedchats.txt"
update.effective_message.reply_document(
document=output,
filename="fedchats.txt",
caption=(
"Here is a list of all the chats that joined the federation {}.")
.format(info['fname']))
def __user_info__(user_id, chat_id):
fed_id = sql.get_fed_id(chat_id)
if fed_id:
fban, fbanreason = sql.get_fban_user(fed_id, user_id)
info = sql.get_fed_info(fed_id)
infoname = info['fname']
if int(info['owner']) == user_id:
text = "This user is the owner of the current Federation: <b>{}</b>.".format(
infoname)
elif is_user_fed_admin(fed_id, user_id):
text = "This user is the admin of the current Federation: <b>{}</b>.".format(
infoname)
elif fban:
text = "Banned in the current Federation: <b>Yes</b>"
text += "\n<b>Reason:</b> {}".format(fbanreason)
else:
text = "Banned in the current Federation: <b>No</b>"
else:
text = ""
return text
def set_frules(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
fed_id = sql.get_fed_id(chat.id)
if not fed_id:
update.effective_message.reply_text(
"This chat is not in any federation!")
return
if is_user_fed_admin(fed_id, user.id) is False:
update.effective_message.reply_text("Only fed admins can do this!")
return
if args:
msg = update.effective_message
raw_text = msg.text
args = raw_text.split(
None, 1) # use python's maxsplit to separate cmd and args
if len(args) == 2:
txt = args[1]
offset = len(txt) - len(
raw_text) # set correct offset relative to command
markdown_rules = markdown_parser(txt,
entities=msg.parse_entities(),
offset=offset)
x = sql.set_frules(fed_id, markdown_rules)
if not x:
update.effective_message.reply_text(
"Big F! There is an error while setting federation rules! If you wonder why, please ask in @HitsukiAyaGroup!"
)
return
rules = sql.get_fed_info(fed_id)['frules']
update.effective_message.reply_text(
f"Rules have been changed to:\n\n{rules}!")
else:
update.effective_message.reply_text("Please write rules to set it up!")
def fed_admin(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
fed_id = sql.get_fed_id(chat.id)
if not fed_id:
update.effective_message.reply_text(
tld(chat.id, "feds_group_not_in_fed"))
return
if is_user_fed_admin(fed_id, user.id) is False:
update.effective_message.reply_text(tld(chat.id, "feds_fedadmin_only"))
return
user = update.effective_user
chat = update.effective_chat
info = sql.get_fed_info(fed_id)
text = tld(chat.id, "feds_admins").format(info['fname'])
text += "Owner:\n"
owner = bot.get_chat(info['owner'])
try:
owner_name = f'{owner.first_name} {owner.last_name}'
except Exception:
owner_name = owner.first_name
text += " • {}\n".format(mention_html(owner.id, owner_name))
members = sql.all_fed_members(fed_id)
if len(members) == 0:
text += tld(chat.id, "feds_noadmins")
else:
text += "\nAdmin:\n"
for x in members:
user = bot.get_chat(x)
text += " • {}\n".format(mention_html(user.id, user.first_name))
update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
def fed_info(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
fed_id = sql.get_fed_id(chat.id)
info = sql.get_fed_info(fed_id)
if not fed_id:
update.effective_message.reply_text(
tld(chat.id, "feds_group_not_in_fed"))
return
if is_user_fed_admin(fed_id, user.id) is False:
update.effective_message.reply_text(tld(chat.id, "feds_fedadmin_only"))
return
owner = bot.get_chat(info['owner'])
try:
owner_name = f'{owner.first_name} {owner.last_name}'
except Exception:
owner_name = owner.first_name
FEDADMIN = sql.all_fed_users(fed_id)
FEDADMIN.append(int(owner.id))
TotalAdminFed = len(FEDADMIN)
user = update.effective_user
chat = update.effective_chat
info = sql.get_fed_info(fed_id)
getfban = sql.get_all_fban_users(fed_id)
getfchat = sql.all_fed_chats(fed_id)
text = tld(chat.id, "feds_info").format(fed_id, info['fname'],
mention_html(owner.id, owner_name),
TotalAdminFed, len(getfban),
len(getfchat))
update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
def fed_ban_list(bot: Bot, update: Update, args: List[str], chat_data):
chat = update.effective_chat
user = update.effective_user
fed_id = sql.get_fed_id(chat.id)
info = sql.get_fed_info(fed_id)
if not fed_id:
update.effective_message.reply_text(
"This group is not a part of any federation!")
return
if is_user_fed_owner(fed_id, user.id) is False:
update.effective_message.reply_text(
"Only federation owners can do this!")
return
user = update.effective_user
chat = update.effective_chat
getfban = sql.get_all_fban_users(fed_id)
if len(getfban) == 0:
update.effective_message.reply_text("The federation ban list of {} is empty.".format(
info['fname']), parse_mode=ParseMode.HTML)
return
if args:
if args[0] == 'json':
jam = time.time()
new_jam = jam + 1800
cek = get_chat(chat.id, chat_data)
if cek.get('status'):
if jam <= int(cek.get('value')):
waktu = time.strftime(
"%H:%M:%S %d/%m/%Y", time.localtime(cek.get('value')))
update.effective_message.reply_text(
"You can back up your data once every 30 minutes!\nYou can back up data again at `{}`".format(waktu), parse_mode=ParseMode.MARKDOWN)
return
else:
if user.id not in SUDO_USERS:
put_chat(chat.id, new_jam, chat_data)
else:
if user.id not in SUDO_USERS:
put_chat(chat.id, new_jam, chat_data)
backups = ""
for users in getfban:
getuserinfo = sql.get_all_fban_users_target(fed_id, users)
json_parser = {"user_id": users, "first_name": getuserinfo['first_name'], "last_name": getuserinfo[
'last_name'], "user_name": getuserinfo['user_name'], "reason": getuserinfo['reason']}
backups += json.dumps(json_parser)
backups += "\n"
with BytesIO(str.encode(backups)) as output:
output.name = "hitsuki_fbanned_users.json"
update.effective_message.reply_document(document=output, filename="hitsuki_fbanned_users.json",
caption="Total {} User are blocked by the Federation {}.".format(len(getfban), info['fname']))
return
elif args[0] == 'csv':
jam = time.time()
new_jam = jam + 1800
cek = get_chat(chat.id, chat_data)
if cek.get('status'):
if jam <= int(cek.get('value')):
waktu = time.strftime(
"%H:%M:%S %d/%m/%Y", time.localtime(cek.get('value')))
update.effective_message.reply_text(
"You can back up data once every 30 minutes!\nYou can back up data again at `{}`".format(waktu), parse_mode=ParseMode.MARKDOWN)
return
else:
if user.id not in SUDO_USERS:
put_chat(chat.id, new_jam, chat_data)
else:
if user.id not in SUDO_USERS:
put_chat(chat.id, new_jam, chat_data)
backups = "id,firstname,lastname,username,reason\n"
for users in getfban:
getuserinfo = sql.get_all_fban_users_target(fed_id, users)
backups += "{user_id},{first_name},{last_name},{user_name},{reason}".format(
user_id=users, first_name=getuserinfo['first_name'], last_name=getuserinfo['last_name'], user_name=getuserinfo['user_name'], reason=getuserinfo['reason'])
backups += "\n"
with BytesIO(str.encode(backups)) as output:
output.name = "hitsuki_fbanned_users.csv"
update.effective_message.reply_document(document=output, filename="hitsuki_fbanned_users.csv",
caption="Total {} User are blocked by Federation {}.".format(len(getfban), info['fname']))
return
text = "<b>{} users have been banned from the federation {}:</b>\n".format(
len(getfban), info['fname'])
for users in getfban:
getuserinfo = sql.get_all_fban_users_target(fed_id, users)
if getuserinfo is False:
text = "There are no users banned from the federation {}".format(
info['fname'])
break
user_name = getuserinfo['first_name']
if getuserinfo['last_name']:
user_name += " " + getuserinfo['last_name']
text += " • {} (<code>{}</code>)\n".format(mention_html(users,
user_name), users)
try:
update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
except Exception:
jam = time.time()
new_jam = jam + 1800
cek = get_chat(chat.id, chat_data)
if cek.get('status'):
if jam <= int(cek.get('value')):
waktu = time.strftime(
"%H:%M:%S %d/%m/%Y", time.localtime(cek.get('value')))
update.effective_message.reply_text(
"You can back up data once every 30 minutes!\nYou can back up data again at `{}`".format(waktu), parse_mode=ParseMode.MARKDOWN)
return
else:
if user.id not in SUDO_USERS:
put_chat(chat.id, new_jam, chat_data)
else:
if user.id not in SUDO_USERS:
put_chat(chat.id, new_jam, chat_data)
cleanr = re.compile('<.*?>')
cleantext = re.sub(cleanr, '', text)
with BytesIO(str.encode(cleantext)) as output:
output.name = "fbanlist.txt"
update.effective_message.reply_document(document=output, filename="fbanlist.txt",
caption="The following is the list of users who are currently fbanned in the Federation {}.".format(info['fname']))
def fed_ban(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
fed_id = sql.get_fed_id(chat.id)
if chat.type == "private":
update.effective_message.reply_text(
tld(chat.id, "common_cmd_group_only"))
return
if not fed_id:
update.effective_message.reply_text(
tld(chat.id, "feds_nofed"))
return
if user.id in (777000, 1087968824):
update.effective_message.reply_text(
tld(chat.id, "feds_tg_bot"))
return
info = sql.get_fed_info(fed_id)
OW = bot.get_chat(info['owner'])
HAHA = OW.id
FEDADMIN = sql.all_fed_users(fed_id)
FEDADMIN.append(int(HAHA))
if is_user_fed_admin(fed_id, user.id) is False:
update.effective_message.reply_text(
tld(chat.id, "feds_notfadmin"))
return
message = update.effective_message
user_id, reason = extract_user_and_text(message, args)
fban, fbanreason = sql.get_fban_user(fed_id, user_id)
if not user_id:
message.reply_text(tld(chat.id, "common_err_no_user"))
return
if user_id == bot.id:
message.reply_text(
"What is funnier than fbanning the bot? Self sacrifice.")
return
if is_user_fed_owner(fed_id, user_id) is True:
message.reply_text("Why did you try the federation fban?")
return
if is_user_fed_admin(fed_id, user_id) is True:
message.reply_text("He is a federation admin, I can't fban him.")
return
if user_id == OWNER_ID:
message.reply_text(
"I don't want to fban my master, that's a very stupid idea!")
return
if int(user_id) in SUDO_USERS:
message.reply_text("I will not fban sudos!")
return
if int(user_id) in WHITELIST_USERS:
message.reply_text(
"This person is whitelisted, so they can't be fbanned!")
return
try:
user_chat = bot.get_chat(user_id)
except BadRequest as excp:
message.reply_text(excp.message)
return
if user_chat.type != 'private':
message.reply_text("That's not a user!")
return
if fban:
user_target = mention_html(user_chat.id, user_chat.first_name)
fed_name = info['fname']
starting = "The reason of federation ban has been replaced for {} in the Federation <b>{}</b>.".format(
user_target, fed_name)
update.effective_message.reply_text(starting,
parse_mode=ParseMode.HTML)
if reason == "":
reason = "No reason given."
temp = sql.un_fban_user(fed_id, user_id)
if not temp:
message.reply_text("Failed to update the reason for fban!")
return
x = sql.fban_user(fed_id, user_id, user_chat.first_name,
user_chat.last_name, user_chat.username, reason)
if not x:
message.reply_text(
"Failed to ban from the federation! If this problem continues, ask in @HitsukiAyaGroup for help!"
)
return
fed_chats = sql.all_fed_chats(fed_id)
for chat in fed_chats:
try:
bot.kick_chat_member(chat, user_id)
except BadRequest as excp:
if excp.message not in FBAN_ERRORS:
LOGGER.warning("Could not fban in {} because: {}".format(
chat, excp.message))
except TelegramError:
pass
send_to_list(bot, FEDADMIN,
"<b>FedBan reason updated</b>"
"\n<b>Federation:</b> {}"
"\n<b>Federation Admin:</b> {}"
"\n<b>User:</b> {}"
"\n<b>User ID:</b> <code>{}</code>"
"\n<b>Reason:</b> {}".format(fed_name, mention_html(user.id,
user.first_name),
mention_html(user_chat.id,
user_chat.first_name),
user_chat.id, reason),
html=True)
message.reply_text("FedBan reason has been updated.")
return
user_target = mention_html(user_chat.id, user_chat.first_name)
fed_name = info['fname']
starting = "Starting a federation ban for {} in the Federation <b>{}</b>.".format(
user_target, fed_name)
update.effective_message.reply_text(starting, parse_mode=ParseMode.HTML)
if reason == "":
reason = "No reason given."
x = sql.fban_user(fed_id, user_id, user_chat.first_name,
user_chat.last_name, user_chat.username, reason)
if not x:
message.reply_text(
"Failed to ban from the federation! If this problem continues, ask in @HitsukiAyaGroup for help."
)
return
fed_chats = sql.all_fed_chats(fed_id)
for chat in fed_chats:
try:
bot.kick_chat_member(chat, user_id)
except BadRequest as excp:
if excp.message in FBAN_ERRORS:
try:
dispatcher.bot.getChat(chat)
except Unauthorized:
sql.chat_leave_fed(chat)
LOGGER.info(
"Chat {} has leave fed {} because bot is kicked".
format(chat, info['fname']))
continue
else:
LOGGER.warning("Cannot fban on {} because: {}".format(
chat, excp.message))
except TelegramError:
pass
send_to_list(bot, FEDADMIN,
"<b>New FedBan</b>"
"\n<b>Federation:</b> {}"
"\n<b>Federation Admin:</b> {}"
"\n<b>User:</b> {}"
"\n<b>User ID:</b> <code>{}</code>"
"\n<b>Reason:</b> {}".format(fed_name, mention_html(user.id,
user.first_name),
mention_html(user_chat.id,
user_chat.first_name),
user_chat.id, reason),
html=True)
message.reply_text("This person has been fbanned")
def fed_import_bans(bot: Bot, update: Update, chat_data):
chat = update.effective_chat
user = update.effective_user
msg = update.effective_message
fed_id = sql.get_fed_id(chat.id)
if not fed_id:
update.effective_message.reply_text(
"This group is not a part of any federation!")
return
if is_user_fed_owner(fed_id, user.id) is False:
update.effective_message.reply_text(
"Only federation owners can do this!")
return
if msg.reply_to_message and msg.reply_to_message.document:
jam = time.time()
new_jam = jam + 1800
cek = get_chat(chat.id, chat_data)
if cek.get('status'):
if jam <= int(cek.get('value')):
waktu = time.strftime(
"%H:%M:%S %d/%m/%Y", time.localtime(cek.get('value')))
update.effective_message.reply_text(
"You can backup your data once every 30 minutes!\nYou can backup data again at `{}`".format(waktu), parse_mode=ParseMode.MARKDOWN)
return
else:
if user.id not in SUDO_USERS:
put_chat(chat.id, new_jam, chat_data)
else:
if user.id not in SUDO_USERS:
put_chat(chat.id, new_jam, chat_data)
if int(int(msg.reply_to_message.document.file_size)/1024) >= 200:
msg.reply_text("This file is too big!")
return
success = 0
failed = 0
try:
file_info = bot.get_file(msg.reply_to_message.document.file_id)
except BadRequest:
msg.reply_text(
"Try downloading and re-uploading the file, this one seems broken!")
return
fileformat = msg.reply_to_message.document.file_name.split('.')[-1]
if fileformat == 'json':
with BytesIO() as file:
file_info.download(out=file)
file.seek(0)
reading = file.read().decode('UTF-8')
splitting = reading.split('\n')
for x in splitting:
if x == '':
continue
try:
data = json.loads(x)
except json.decoder.JSONDecodeError:
failed += 1
continue
try:
# Make sure it int
import_userid = int(data['user_id'])
import_firstname = str(data['first_name'])
import_lastname = str(data['last_name'])
import_username = str(data['user_name'])
import_reason = str(data['reason'])
except ValueError:
failed += 1
continue
# Checking user
if int(import_userid) == bot.id:
failed += 1
continue
if is_user_fed_owner(fed_id, import_userid) is True:
failed += 1
continue
if is_user_fed_admin(fed_id, import_userid) is True:
failed += 1
continue
if str(import_userid) == str(OWNER_ID):
failed += 1
continue
if int(import_userid) in SUDO_USERS:
failed += 1
continue
if int(import_userid) in WHITELIST_USERS:
failed += 1
continue
addtodb = sql.fban_user(fed_id, str(
import_userid), import_firstname, import_lastname, import_username, import_reason)
if addtodb:
success += 1
text = "Successfully imported! {} people are fbanned.".format(
success)
if failed >= 1:
text += " {} Failed to import.".format(failed)
elif fileformat == 'csv':
with BytesIO() as file:
file_info.download(out=file)
file.seek(0)
reading = file.read().decode('UTF-8')
splitting = reading.split('\n')
for x in splitting:
if x == '':
continue
data = x.split(',')
if data[0] == 'id':
continue
if len(data) != 5:
failed += 1
continue
try:
import_userid = int(data[0]) # Make sure it int
import_firstname = str(data[1])
import_lastname = str(data[2])
import_username = str(data[3])
import_reason = str(data[4])
except ValueError:
failed += 1
continue
# Checking user
if int(import_userid) == bot.id:
failed += 1
continue
if is_user_fed_owner(fed_id, import_userid) is True:
failed += 1
continue
if is_user_fed_admin(fed_id, import_userid) is True:
failed += 1
continue
if str(import_userid) == str(OWNER_ID):
failed += 1
continue
if int(import_userid) in SUDO_USERS:
failed += 1
continue
if int(import_userid) in WHITELIST_USERS:
failed += 1
continue
addtodb = sql.fban_user(fed_id, str(
import_userid), import_firstname, import_lastname, import_username, import_reason)
if addtodb:
success += 1
text = "Successfully imported. {} people are fbanned.".format(
success)
if failed >= 1:
text += " {} failed to import.".format(failed)
else:
update.effective_message.reply_text("File not supported.")
return
update.effective_message.reply_text(text)
def unfban(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat
user = update.effective_user
message = update.effective_message
fed_id = sql.get_fed_id(chat.id)
if not fed_id:
update.effective_message.reply_text(
"This group is not a part of any federation!")
return
if is_user_fed_admin(fed_id, user.id) is False:
update.effective_message.reply_text(
"Only federation admins can do this!")
return
user_id = extract_user(message, args)
if not user_id:
message.reply_text("You do not seem to be referring to a user.")
return
user_chat = bot.get_chat(user_id)
if user_chat.type != 'private':
message.reply_text("That's not a user!")
return
fban, fbanreason = sql.get_fban_user(fed_id, user_id)
if fban is False:
message.reply_text("This user is not fbanned!")
if not fbanreason:
return
return
message.reply_text(
"I'll give {} a second chance in this federation".format(
user_chat.first_name))
chat_list = sql.all_fed_chats(fed_id)
for chat in chat_list:
try:
member = bot.get_chat_member(chat, user_id)
if member.status == 'kicked':
bot.unban_chat_member(chat, user_id)
except BadRequest as excp:
if excp.message not in UNFBAN_ERRORS:
LOGGER.warning("Cannot remove fban on {} because: {}".format(
chat, excp.message))
except TelegramError:
pass
try:
x = sql.un_fban_user(fed_id, user_id)
if not x:
message.reply_text(
"Fban failure, this user may have been un-fedbanned!")
return
except Exception:
pass
message.reply_text("This person is un-fbanned.")
