def set_frules(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
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 chat is not in any federation!")
return
if is_user_fed_admin(fed_id, user.id) == False:
update.effective_message.reply_text("Only fed admins can do this!")
return
if len(args) >= 1:
msg = update.effective_message # type: Optional[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 wondered why please ask it in @onepunchsupport !")
return
rules = sql.get_fed_info(fed_id)['frules']
update.effective_message.reply_text(f"Rules have been changed to :\n{rules}!")
else:
update.effective_message.reply_text("Please write rules to set it up!")
def fed_notif(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
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)
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 back up! Every user who is fban / unfban you will be notified via PM.")
elif args[0] in ("no", "off"):
sql.set_feds_setting(user.id, False)
msg.reply_text("Reporting Federation has stopped! Every user who is fban / unfban you will not be notified via PM.")
else:
msg.reply_text("Please enter `on`/`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 fed_chat(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
fed_id = sql.get_fed_id(chat.id)
user_id = update.effective_message.from_user.id
if not is_user_admin(update.effective_chat, user_id):
update.effective_message.reply_text("You must be an admin to execute this command")
return
if not fed_id:
update.effective_message.reply_text("This group is not in any federation!")
return
user = update.effective_user # type: Optional[Chat]
chat = update.effective_chat # type: Optional[Chat]
info = sql.get_fed_info(fed_id)
text = "This chat is part of the following federation:"
text += "\n{} (ID: <code>{}</code>)".format(info['fname'], fed_id)
update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
def del_fed(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
if chat.type != "private":
update.effective_message.reply_text("Delete your federation in my PM, not in the group.")
return
if args:
is_fed_id = args[0]
getinfo = sql.get_fed_info(is_fed_id)
if getinfo == False:
update.effective_message.reply_text("This federation is not found")
return
if int(getinfo['owner']) == int(user.id):
fed_id = is_fed_id
else:
update.effective_message.reply_text("Only federation owners can do this!")
return
else:
update.effective_message.reply_text("What should I delete?")
return
if is_user_fed_owner(fed_id, user.id) == False:
update.effective_message.reply_text("Only federation owners can do this!")
return
update.effective_message.reply_text("Are you sure you want to delete your federation? This action cannot be canceled, you will lose your entire ban list, and '{}' will be permanently lost.".format(getinfo['fname']),
reply_markup=InlineKeyboardMarkup(
[[InlineKeyboardButton(text="ā ļø Remove Federation ā ļø", callback_data="rmfed_{}".format(fed_id))],
[InlineKeyboardButton(text="Cancel", callback_data="rmfed_cancel")]]))
def connected(bot, update, chat, user_id, need_admin=True):
user = update.effective_user # type: Optional[User]
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
if chat.type == chat.PRIVATE and tg_bot.modules.sql.connection_sql.get_connected_chat(user_id):
conn_id = tg_bot.modules.sql.connection_sql.get_connected_chat(user_id).chat_id
getstatusadmin = bot.get_chat_member(conn_id, update.effective_message.from_user.id)
isadmin = getstatusadmin.status in ('administrator', 'creator')
ismember = getstatusadmin.status in ('member')
isallow = tg_bot.modules.sql.connection_sql.allow_connect_to_chat(conn_id)
if (isadmin) or (isallow and ismember) or (user.id in SUDO_USERS) or (user.id in DEV_USERS):
if need_admin == True:
if getstatusadmin.status in ('administrator', 'creator') or user_id in SUDO_USERS or user_id in DEV_USERS:
return conn_id
else:
update.effective_message.reply_text("You must be an admin in the connected group!")
raise Exception("Not an Admin")
else:
return conn_id
else:
update.effective_message.reply_text("This group has changed the connection rights or you are no longer an admin. Disconnecting chat!")
disconnect_chat(bot, update)
raise Exception("Not an Admin")
else:
return False
def connection_chat(bot: Bot, update: Update):
chat = update.effective_chat
user = update.effective_user
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return
conn = connected(bot, update, chat, user.id, need_admin=True)
if conn:
chat = dispatcher.bot.getChat(conn)
chat_name = dispatcher.bot.getChat(conn).title
else:
if update.effective_message.chat.type != "private":
return
chat = update.effective_chat
chat_name = update.effective_message.chat.title
if conn:
message = "You are currently connected with {}.\n".format(chat_name)
else:
message = "You are currently not connected in any group.\n"
send_message(update.effective_message, message, parse_mode="markdown")
def disconnect_chat(bot, update):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
if update.effective_chat.type == 'private':
disconnection_status = tg_bot.modules.sql.connection_sql.disconnect(update.effective_message.from_user.id)
if disconnection_status:
tg_bot.modules.sql.connection_sql.disconnected_chat = update.effective_message.reply_text("Disconnected from chat!")
else:
update.effective_message.reply_text("Unable to disconnect from the chat!")
else:
update.effective_message.reply_text("Use is limited to PMs")
def disconnect_chat(bot: Bot, update: Update):
chat = update.effective_chat
msg = update.effective_message
spam = spamfilters(msg.text, msg.from_user.id, chat.id)
if spam is True:
return
if chat.type == 'private':
disconnection_status = sql.disconnect(msg.from_user.id)
if disconnection_status:
sql.disconnected_chat = send_message(msg, "Disconnected from chat!")
else:
send_message(msg, "You're not connected!")
else:
send_message(msg, "This command is only available in PM.")
def get_frules(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
chat = update.effective_chat # type: Optional[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"
text += rules
update.effective_message.reply_text(text, parse_mode=ParseMode.MARKDOWN)
def user_join_fed(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
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)
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("I cannot extract users from this message")
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("Why are you trying to promote a federation owner?")
return
if getuser:
update.effective_message.reply_text("I cannot promote users who are already federation admins! But I can remove them if you want!")
return
if user_id == bot.id:
update.effective_message.reply_text("I already am a federation admin in all federations!")
return
res = sql.user_join_fed(fed_id, user_id)
if res:
update.effective_message.reply_text("š Successfully Promoted!")
else:
update.effective_message.reply_text("Failed to promote!")
else:
update.effective_message.reply_text("Only federation owners can do this!")
def leave_fed(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[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) == True:
update.effective_message.reply_text("This chat has left the federation: {}!".format(fed_info['fname']))
else:
update.effective_message.reply_text("How can you leave a federation that you never joined?!")
else:
update.effective_message.reply_text("Only group creators can use this command!")
def user_demote_fed(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
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):
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("I cannot extract users from this message")
return
else:
LOGGER.warning('error')
if user_id == bot.id:
update.effective_message.reply_text("Are you trying to demote me as a federation admin? Do you think I am stupid?")
return
if sql.search_user_in_fed(fed_id, user_id) == False:
update.effective_message.reply_text("I cannot demote people who are not federation admins!")
return
res = sql.user_demote_fed(fed_id, user_id)
if res == True:
update.effective_message.reply_text("Get out of here!")
else:
update.effective_message.reply_text("Demotion failed!")
else:
update.effective_message.reply_text("Only federation owners can do this!")
return
def fed_info(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
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 in any federation!")
return
if is_user_fed_admin(fed_id, user.id) == False:
update.effective_message.reply_text("Only a federation admin can do this!")
return
owner = bot.get_chat(info['owner'])
try:
owner_name = owner.first_name + " " + owner.last_name
except:
owner_name = owner.first_name
FEDADMIN = sql.all_fed_users(fed_id)
FEDADMIN.append(int(owner.id))
TotalAdminFed = len(FEDADMIN)
user = update.effective_user # type: Optional[Chat]
chat = update.effective_chat # type: Optional[Chat]
info = sql.get_fed_info(fed_id)
text = "<b>ā¹ļø Federation Information:</b>"
text += "\nFedID: <code>{}</code>".format(fed_id)
text += "\nName: {}".format(info['fname'])
text += "\nCreator: {}".format(mention_html(owner.id, owner_name))
text += "\nAll Admins: <code>{}</code>".format(TotalAdminFed)
getfban = sql.get_all_fban_users(fed_id)
text += "\nTotal banned users: <code>{}</code>".format(len(getfban))
getfchat = sql.all_fed_chats(fed_id)
text += "\nNumber of groups in this federation: <code>{}</code>".format(len(getfchat))
update.effective_message.reply_text(text, parse_mode=ParseMode.HTML)
def fed_admin(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
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 in any federation!")
return
if is_user_fed_admin(fed_id, user.id) == False:
update.effective_message.reply_text("Only federation admins can do this!")
return
user = update.effective_user # type: Optional[Chat]
chat = update.effective_chat # type: Optional[Chat]
info = sql.get_fed_info(fed_id)
text = "<b>Federation Admin {}:</b>\n\n".format(info['fname'])
text += "š Owner:\n"
owner = bot.get_chat(info['owner'])
try:
owner_name = owner.first_name + " " + owner.last_name
except:
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 += "\nš± There is no admin in this federation"
else:
text += "\nš± Admin:\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 join_fed(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message
administrators = chat.get_administrators()
fed_id = sql.get_fed_id(chat.id)
if user.id in SUDO_USERS:
pass
else:
for admin in administrators:
status = admin.status
if status == "creator":
if str(admin.user.id) == str(user.id):
pass
else:
update.effective_message.reply_text("Only group creators can use this command!")
return
if fed_id:
message.reply_text("You cannot join two federations from one chat")
return
if len(args) >= 1:
getfed = sql.search_fed_by_id(args[0])
if getfed == False:
message.reply_text("Please enter a valid federation ID")
return
x = sql.chat_join_fed(args[0], chat.id)
if not x:
message.reply_text("Failed to join federation! Please contact @onepunchsupport if this problem still persists!")
return
message.reply_text("This chat has joined the federation: {}!".format(getfed['fname']))
def new_fed(bot: Bot, update: Update):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
chat = update.effective_chat # type: Optional[Chat]
user = update.effective_user # type: Optional[User]
message = update.effective_message
if chat.type != "private":
update.effective_message.reply_text("Make your federation in my PM, not in a group.")
return
fednam = message.text.split(None, 1)[1]
if not fednam == '':
fed_id = str(uuid.uuid4())
fed_name = fednam
LOGGER.info(fed_id)
# Currently only for creator
#if fednam == 'Team Nusantara Disciplinary Circle':
#fed_id = "TeamNusantaraDevs"
x = sql.new_fed(user.id, fed_name, fed_id)
if not x:
update.effective_message.reply_text("Can't federate! Please contact my maker if the problem still persists.")
return
update.effective_message.reply_text("*You have succeeded in creating a new federation!*"\
"\nName: `{}`"\
"\nID: `{}`"
"\n\nUse the command below to join the federation:"
"\n`/joinfed {}`".format(fed_name, fed_id, fed_id), parse_mode=ParseMode.MARKDOWN)
try:
bot.send_message(GBAN_LOGS,
"Federation <b>{}</b> has been created with ID: <pre>{}</pre>".format(fed_name, fed_id), parse_mode=ParseMode.HTML)
except:
LOGGER.warning("Cannot send a message to GBAN_LOGS")
else:
update.effective_message.reply_text("Please write down the name of the federation")
def fed_chats(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
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_admin(fed_id, user.id) == 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>New chat 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:
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="Here is a list of all the chats that joined the federation {}.".format(info['fname']))
def fed_broadcast(bot: Bot, update: Update, args: List[str]):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
msg = update.effective_message # type: Optional[Message]
user = update.effective_user # type: Optional[User]
if args:
chat = update.effective_chat # type: Optional[Chat]
fed_id = sql.get_fed_id(chat.id)
fedinfo = sql.get_fed_info(fed_id)
text = "*New broadcast from the Federation {}*\n".format(fedinfo['fname'])
# Parsing md
raw_text = msg.text
args = raw_text.split(None, 1) # use python's maxsplit to separate cmd and args
txt = args[1]
offset = len(txt) - len(raw_text) # set correct offset relative to command
text_parser = markdown_parser(txt, entities=msg.parse_entities(), offset=offset)
text += text_parser
try:
broadcaster = user.first_name
except:
broadcaster = user.first_name + " " + user.last_name
text += "\n\n- {}".format(mention_markdown(user.id, broadcaster))
chat_list = sql.all_fed_chats(fed_id)
failed = 0
for chat in chat_list:
try:
bot.sendMessage(chat, text, parse_mode="markdown")
except TelegramError:
failed += 1
LOGGER.warning("Couldn't send broadcast to %s, group name %s", str(chat.chat_id), str(chat.chat_name))
send_text = "The federation broadcast is complete"
if failed >= 1:
send_text += "{} the group failed to receive the message, probably because it left the Federation.".format(failed)
update.effective_message.reply_text(send_text)
def fed_import_bans(bot: Bot, update: Update, chat_data):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
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 = "Blocks were successfully imported. {} people are blocked.".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 = "Blocked files were imported successfully. {} people are blocked.".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_list(bot: Bot, update: Update, args: List[str], chat_data):
spam = spamfilters(update.effective_message.text, update.effective_message.from_user.id, update.effective_chat.id)
if spam == True:
return update.effective_message.reply_text("Spammer detected! Ignoring user.")
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']))