def fed_import_bans(bot: Bot, update: Update, chat_data):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
msg = update.effective_message # type: Optional[Message]
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) == 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 you rdata 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 as err:
failed += 1
continue
try:
import_userid = int(data['user_id']) # Make sure it int
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) == True:
failed += 1
continue
if is_user_fed_admin(fed_id, import_userid) == 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) == True:
failed += 1
continue
if is_user_fed_admin(fed_id, import_userid) == 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 fed_ban(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
fed_id = sql.get_fed_id(chat.id)
info = sql.get_fed_info(fed_id)
OW = bot.get_chat(info.owner_id)
HAHA = OW.id
FEDADMIN = sql.all_fed_users(fed_id)
FEDADMIN.append(int(HAHA))
if is_user_fed_admin(fed_id, user.id) == False:
update.effective_message.reply_text(
tld(chat.id, "Only fed admins can do this!"))
return
message = update.effective_message # type: Optional[Message]
user_id, reason = extract_user_and_text(message, args)
if not user_id:
message.reply_text(
tld(chat.id, "You don't seem to be referring to a user."))
return
if user_id == bot.id:
message.reply_text(
tld(
chat.id,
"You can't fban me, better hit your head against the wall, it's more fun."
))
return
if is_user_fed_owner(fed_id, user_id) == True:
message.reply_text(
tld(chat.id, "Why you are trying to fban the federation owner?"))
return
if is_user_fed_admin(fed_id, user_id) == True:
message.reply_text(
tld(chat.id,
"Why so serious trying to fban the federation admin?"))
return
if user_id == OWNER_ID:
message.reply_text(
tld(chat.id,
"I'm not fbanning my master, That's pretty dumb idea!"))
return
if int(user_id) in SUDO_USERS:
message.reply_text(tld(chat.id, "I'm not fbanning the bot sudoers!"))
return
if int(user_id) in WHITELIST_USERS:
message.reply_text(
tld(chat.id, "This person is whitelist from being 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(tld(chat.id, "That's not a user!"))
return
message.reply_text(tld(chat.id, "Start fbanning!"))
if reason == "":
message.reply_text(
tld(chat.id,
"You have entered no reason, fbanning without reason!"))
reason = "No Reason have been given"
sql.fban_user(fed_id, user_id, reason)
h = sql.all_fed_chats(fed_id)
for O in h:
try:
bot.kick_chat_member(O, user_id)
#text = tld(chat.id, "I should gban {}, but it's only test fban, right? So i let him live.").format(O)
text = "Fbanning {}".format(user_id)
#message.reply_text(text)
except BadRequest as excp:
if excp.message in FBAN_ERRORS:
pass
else:
message.reply_text(
tld(chat.id,
"Could not fban due to: {}").format(excp.message))
return
except TelegramError:
pass
send_to_list(bot, FEDADMIN,
"<b>New FedBan</b>" \
"\n<b>Fed:</b> {}" \
"\n<b>FedAdmin:</b> {}" \
"\n<b>User:</b> {}" \
"\n<b>User ID:</b> <code>{}</code>" \
"\n<b>Reason:</b> {}".format(info.fed_name, mention_html(user.id, user.first_name),
mention_html(user_chat.id, user_chat.first_name),
user_chat.id, reason),
html=True)
def fed_stat_user(bot, update, args):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
msg = update.effective_message # type: Optional[Message]
if args:
if args[0].isdigit():
user_id = args[0]
else:
user_id = extract_user(msg, args)
else:
user_id = extract_user(msg, args)
if user_id:
if len(args) == 2 and args[0].isdigit():
fed_id = args[1]
user_name, reason, fbantime = sql.get_user_fban(fed_id, str(user_id))
if fbantime:
fbantime = time.strftime("%d/%m/%Y", time.localtime(fbantime))
else:
fbantime = "Unavaiable"
if user_name == False:
send_message(update.effective_message, tld(update.effective_message, "Federation {} not found!").format(fed_id), parse_mode="markdown")
return
if user_name == "" or user_name == None:
user_name = tld(update.effective_message, "Day")
if not reason:
send_message(update.effective_message, tld(update.effective_message, "{} has not been banned in this federation!").format(user_name))
else:
text = tld(update.effective_message, "{} banned in this federation because:\n`{}`\n*Banned on:* `{}`").format(user_name, reason, fbantime)
send_message(update.effective_message, text, parse_mode="markdown")
return
user_name, fbanlist = sql.get_user_fbanlist(str(user_id))
if user_name == "":
try:
user_name = bot.get_chat(user_id).first_name
except BadRequest:
user_name = tld(update.effective_message, "Day")
if user_name == "" or user_name == None:
user_name = tld(update.effective_message, "Day")
if len(fbanlist) == 0:
send_message(update.effective_message, tld(update.effective_message, "{} not yet banned in any federation!").format(user_name))
return
else:
text = tld(update.effective_message, "{} has been banned in this federation:\n").format(user_name)
for x in fbanlist:
text += "- `{}`: {}\n".format(x[0], x[1][:20])
text += tld(update.effective_message, "\nIf you want to find out more about the specific reasons for fedban, use it /fbanstat <FedID>")
send_message(update.effective_message, text, parse_mode="markdown")
elif not msg.reply_to_message and not args:
user_id = msg.from_user.id
user_name, fbanlist = sql.get_user_fbanlist(user_id)
if user_name == "":
user_name = msg.from_user.first_name
if len(fbanlist) == 0:
send_message(update.effective_message, tld(update.effective_message, "{} not yet banned in any federation!").format(user_name))
else:
text = tld(update.effective_message, "{} has been banned in this federation:\n").format(user_name)
for x in fbanlist:
text += "- `{}`: {}\n".format(x[0], x[1][:20])
text += tld(update.effective_message, "\nIf you want to find out more about the specific reasons for fedban, use it /fbanstat <FedID>")
send_message(update.effective_message, text, parse_mode="markdown")
else:
fed_id = args[0]
fedinfo = sql.get_fed_info(fed_id)
if not fedinfo:
send_message(update.effective_message, tld(update.effective_message, "Federation {} not found!").format(fed_id))
return
name, reason, fbantime = sql.get_user_fban(fed_id, msg.from_user.id)
if fbantime:
fbantime = time.strftime("%d/%m/%Y", time.localtime(fbantime))
else:
fbantime = "Unavaiable"
if not name:
name = msg.from_user.first_name
if not reason:
send_message(update.effective_message, tld(update.effective_message, "{} not banned in this federation").format(name))
return
send_message(update.effective_message, tld(update.effective_message, "{} banned in this federation because:\n`{}`\n*Banned on:* `{}`").format(name, reason, fbantime), parse_mode="markdown")
def fed_ban_list(bot: Bot, update: Update, args: List[str], chat_data):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[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) == False:
update.effective_message.reply_text("Only Federation owners can do this!")
return
user = update.effective_user # type: Optional[Chat]
chat = update.effective_chat # type: Optional[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 backup 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 = "saitama_fbanned_users.json"
update.effective_message.reply_document(document=output, filename="saitama_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 = "saitama_fbanned_users.csv"
update.effective_message.reply_document(document=output, filename="saitama_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 == 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:
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 a list of users who are currently fbanned in the Federation {}.".format(info['fname']))
def unfban(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[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
info = sql.get_fed_info(fed_id)
if is_user_fed_admin(fed_id, user.id) == 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 == False:
message.reply_text("This user is not fbanned!")
return
banner = update.effective_user # type: Optional[User]
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)
"""
bot.send_message(chat, "<b>Un-FedBan</b>" \
"\n<b>Federation:</b> {}" \
"\n<b>Federation Admin:</b> {}" \
"\n<b>User:</b> {}" \
"\n<b>User ID:</b> <code>{}</code>".format(info['fname'], mention_html(user.id, user.first_name), mention_html(user_chat.id, user_chat.first_name),
user_chat.id), parse_mode="HTML")
"""
except BadRequest as excp:
if excp.message in UNFBAN_ERRORS:
pass
else:
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:
pass
message.reply_text("This person is un-fbanned.")
FEDADMIN = sql.all_fed_users(fed_id)
def fed_ban(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
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
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) == False:
update.effective_message.reply_text("Only federation admins can do this!")
return
message = update.effective_message # type: Optional[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("You don't seem to be referring to a user")
return
if user_id == bot.id:
message.reply_text("What is funnier than kicking the group creator? Self sacrifice.")
return
if is_user_fed_owner(fed_id, user_id) == True:
message.reply_text("Why did you try the federation fban?")
return
if is_user_fed_admin(fed_id, user_id) == 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 block my master, that's a very stupid idea!")
return
if int(user_id) in SUDO_USERS:
message.reply_text("I will not use sudo fban!")
return
if int(user_id) in WHITELIST_USERS:
message.reply_text("This person is whitelisted, so they can't be fban!")
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 fban is 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 fedban!")
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, contact @onepunchsupport.")
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:
pass
else:
LOGGER.warning("Could not fban on {} 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, contact @onepunchsupport.")
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 unfban(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message # type: Optional[Message]
fed_id = sql.get_fed_id(chat.id)
if not fed_id:
update.effective_message.reply_text(
tld(chat.id, "This group is not in any federation!"))
return
info = sql.get_fed_info(fed_id)
if is_user_fed_admin(fed_id, user.id) == False:
update.effective_message.reply_text(
tld(chat.id, "Only fed admins can do this!"))
return
user_id = extract_user(message, args)
if not user_id:
message.reply_text(
tld(chat.id, "You don't seem to be referring to a user."))
return
user_chat = bot.get_chat(user_id)
if user_chat.type != 'private':
message.reply_text(tld(chat.id, "That's not a user!"))
return
if sql.get_fban_user(fed_id, user_id) == False:
message.reply_text(tld(chat.id, "This user is not fbanned!"))
return
banner = update.effective_user # type: Optional[User]
message.reply_text(
tld(chat.id,
"I'll give {} a second chance in this federation.").format(
user_chat.first_name))
h = sql.all_fed_chats(fed_id)
for O in h:
try:
member = bot.get_chat_member(O, user_id)
if member.status == 'kicked':
bot.unban_chat_member(O, user_id)
except BadRequest as excp:
if excp.message in UNFBAN_ERRORS:
pass
else:
message.reply_text(
tld(chat.id,
"Could not un-fban due to: {}").format(excp.message))
return
except TelegramError:
pass
try:
x = sql.un_fban_user(fed_id, user_id)
if not x:
message.reply_text(
tld(chat.id,
"Failed to fban, This user is probably fbanned!"))
return
except:
pass
message.reply_text(tld(chat.id, "Person has been un-fbanned."))
OW = bot.get_chat(info.owner_id)
HAHA = OW.id
FEDADMIN = sql.all_fed_users(fed_id)
FEDADMIN.append(int(HAHA))
send_to_list(bot, FEDADMIN,
"<b>Un-FedBan</b>" \
"\n<b>Fed:</b> {}" \
"\n<b>FedAdmin:</b> {}" \
"\n<b>User:</b> {}" \
"\n<b>User ID:</b> <code>{}</code>".format(info.fed_name, mention_html(user.id, user.first_name),
mention_html(user_chat.id, user_chat.first_name),
user_chat.id),
html=True)
def fed_ban(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
fed_id = sql.get_fed_id(chat.id)
if not fed_id:
update.effective_message.reply_text(
tld(chat.id, "This group is not in any federation!"))
return
info = sql.get_fed_info(fed_id)
OW = bot.get_chat(info.owner_id)
HAHA = OW.id
FEDADMIN = sql.all_fed_users(fed_id)
FEDADMIN.append(int(HAHA))
if is_user_fed_admin(fed_id, user.id) == False:
update.effective_message.reply_text(
tld(chat.id, "Only fed admins can do this!"))
return
message = update.effective_message # type: Optional[Message]
user_id, reason = extract_user_and_text(message, args)
fban = sql.get_fban_user(fed_id, user_id)
if not fban == False:
update.effective_message.reply_text(
tld(chat.id, "*Cough* This user is already fbanned!"))
return
if not user_id:
message.reply_text(
tld(chat.id, "You don't seem to be referring to a user."))
return
if user_id == bot.id:
message.reply_text(
tld(
chat.id,
"You can't fban me, better hit your head against the wall, it's more fun."
))
return
if is_user_fed_owner(fed_id, user_id) == True:
message.reply_text(
tld(chat.id, "Why you are trying to fban the federation owner?"))
return
if is_user_fed_admin(fed_id, user_id) == True:
message.reply_text(
tld(chat.id,
"Why so serious trying to fban the federation admin?"))
return
if user_id == OWNER_ID:
message.reply_text(
tld(chat.id,
"I'm not fbanning my master AVATAR, That's pretty dumb idea!"))
return
if int(user_id) in SUDO_USERS:
message.reply_text(tld(chat.id, "I'm not fbanning the bot sudoers!"))
return
if int(user_id) in WHITELIST_USERS:
message.reply_text(
tld(chat.id, "This person is whitelisted from being 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(tld(chat.id, "That's not a user!"))
return
ok123 = mention_html(user_chat.id, user_chat.first_name)
ok1234 = info.fed_name
text12 = f"Beginning federation ban of {ok123} in {ok1234}."
update.effective_message.reply_text(text12, parse_mode=ParseMode.HTML)
if reason == "":
reason = "No Reason."
x = sql.fban_user(fed_id, user_id, reason)
if not x:
message.reply_text(
"Failed to federation ban! Probably this bug is not fixed yet due to the developer is lazy as f**k."
)
return
h = sql.all_fed_chats(fed_id)
for O in h:
try:
bot.kick_chat_member(O, user_id)
#text = tld(chat.id, "I should fban {}, but it's only test fban, right? So i let him live.").format(O)
text = "Fbanning {}".format(user_id)
#message.reply_text(text)
except BadRequest as excp:
if excp.message in FBAN_ERRORS:
pass
else:
message.reply_text(
tld(chat.id,
"Could not fban due to: {}").format(excp.message))
return
except TelegramError:
pass
send_to_list(bot, FEDADMIN,
"<b>New FedBan</b>" \
"\n<b>Fed:</b> {}" \
"\n<b>FedAdmin:</b> {}" \
"\n<b>User:</b> {}" \
"\n<b>User ID:</b> <code>{}</code>" \
"\n<b>Reason:</b> {}".format(info.fed_name, mention_html(user.id, user.first_name),
mention_html(user_chat.id, user_chat.first_name),
user_chat.id, reason),
html=True)
text13 = f"Chu {ok123} Sucessfully Fbanned in {ok1234} Fed."
update.effective_message.reply_text(text13, parse_mode=ParseMode.HTML)
def user_join_fed(bot: Bot, update: Update, args: List[str]):
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
fed_id = sql.get_fed_id(chat.id)
if is_user_fed_owner(fed_id, user.id) == False:
update.effective_message.reply_text(
tld(chat.id, "Only fed owner can do this!"))
return
msg = update.effective_message # type: Optional[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, "I can't extract a user from this."))
return
else:
return
print(sql.search_user_in_fed(fed_id, user_id))
#if user_id == user_id:
# update.effective_message.reply_text(tld(chat.id, "Are you gonna promote yourself?"))
# return
fed_id = sql.get_fed_id(chat.id)
info = sql.get_fed_info(fed_id)
OW = bot.get_chat(info.owner_id)
HAHA = OW.id
if user_id == HAHA:
update.effective_message.reply_text(
tld(chat.id, "Why are you trying to promote federation owner!?"))
return
if not sql.search_user_in_fed(fed_id, user_id) == False:
update.effective_message.reply_text(
tld(
chat.id,
"I can't promote user which is already a fed admin! But I can demote them."
))
return
if user_id == bot.id:
update.effective_message.reply_text(
tld(
chat.id,
"I am already the federation admin and the one that manage it!"
))
return
#else:
# return
res = sql.user_join_fed(fed_id, user_id)
if not res:
update.effective_message.reply_text(
tld(
chat.id,
"Failed to promoted! It might be because you are admin in another federation! Our code is still buggy, We are sorry for that!"
))
return
update.effective_message.reply_text(tld(chat.id, "Promoted Successfully!"))
