def delete_rules(self, guild_id: int) -> int:
return session.query(ACL_rule).filter(ACL_rule.guild_id == guild_id).delete()
def deleteId(self, discord_id: int) -> int:
count = session.query(User).filter(
User.discord_id == discord_id).delete()
session.commit()
return count
def filterStatus(self, status: str):
return session.query(User).filter(User.status == status).all()
def get(self, discord_id: int):
"""Get user from database"""
return session.query(User).filter(
User.discord_id == discord_id).one_or_none()
def getByPrefix(self, prefix: str):
"""Get users from database"""
return session.query(User).filter(User.login.startswith(prefix)).all()
async def increment_roles(self, ctx):
database.base.metadata.create_all(database.db)
guild = self.bot.get_guild(config.guild_id)
BIT_names = [str(x) + "BIT" + ("+" if x == 4 else "")
for x in range(5)]
BIT = [discord.utils.get(guild.roles, name=role_name)
for role_name in BIT_names]
MIT_names = [str(x) + "MIT" + ("+" if x == 3 else "")
for x in range(4)]
MIT = [discord.utils.get(guild.roles, name=role_name)
for role_name in MIT_names]
# pridat kazdeho 3BIT a 2MIT cloveka do DB pred tim nez je jebnem do
# 4BIT+ respektive 3MIT+ role kvuli rollbacku
session.query(User_backup).delete()
for member in BIT[3].members:
session.add(User_backup(member_ID=member.id))
for member in MIT[2].members:
session.add(User_backup(member_ID=member.id))
session.commit()
for member in BIT[3].members:
await member.add_roles(BIT[4])
for member in MIT[2].members:
await member.add_roles(MIT[3])
BIT_colors = [role.color for role in BIT]
await BIT[3].delete()
await BIT[2].edit(name="3BIT", color=BIT_colors[3])
await BIT[1].edit(name="2BIT", color=BIT_colors[2])
await BIT[0].edit(name="1BIT", color=BIT_colors[1])
bit0 = await guild.create_role(name='0BIT', color=BIT_colors[0])
await bit0.edit(position=BIT[0].position - 1)
MIT_colors = [role.color for role in MIT]
await MIT[2].delete()
await MIT[1].edit(name="2MIT", color=MIT_colors[2])
await MIT[0].edit(name="1MIT", color=MIT_colors[1])
mit0 = await guild.create_role(name='0MIT', color=MIT_colors[0])
await mit0.edit(position=MIT[0].position - 1)
general_names = [str(x) + "bit-general" for x in range(4)]
terminy_names = [str(x) + "bit-terminy" for x in range(1, 3)]
general_channels = [discord.utils.get(guild.channels,
name=channel_name)
for channel_name in general_names]
terminy_channels = [discord.utils.get(guild.channels,
name=channel_name)
for channel_name in terminy_names]
# TODO: do smth about 4bit general next year, delete it in the meantime
bit4_general = discord.utils.get(guild.channels, name="4bit-general")
if bit4_general is not None:
await bit4_general.delete()
# move names
await general_channels[3].edit(name="4bit-general")
await general_channels[2].edit(name="3bit-general")
await general_channels[1].edit(name="2bit-general")
await general_channels[0].edit(name="1bit-general")
# create 0bit-general
overwrites = {
guild.default_role:
discord.PermissionOverwrite(read_messages=False),
discord.utils.get(guild.roles, name="0BIT"):
discord.PermissionOverwrite(read_messages=True,
send_messages=True)
}
await guild.create_text_channel(
'0bit-general', overwrites=overwrites,
category=general_channels[0].category,
position=general_channels[0].position - 1
)
# delete 3bit-terminy
await discord.utils.get(guild.channels, name="3bit-terminy").delete()
await terminy_channels[1].edit(name="3bit-terminy")
await terminy_channels[0].edit(name="2bit-terminy")
# create 1bit-terminy
overwrites = {
guild.default_role:
discord.PermissionOverwrite(read_messages=False),
discord.utils.get(guild.roles, name="1BIT"):
discord.PermissionOverwrite(read_messages=True,
send_messages=False)
}
await guild.create_text_channel(
'1bit-terminy', overwrites=overwrites,
category=terminy_channels[0].category,
position=terminy_channels[0].position - 1
)
# give 4bit perms to the new 3bit terminy
await terminy_channels[1].set_permissions(
discord.utils.get(guild.roles, name="4BIT+"),
read_messages=True, send_messages=False
)
# Give people the correct mandatory classes after increment
semester_names = [str(x) + ". Semestr" for x in range(1, 6)]
semester = [discord.utils.get(guild.categories, name=semester_name)
for semester_name in semester_names]
await semester[0].set_permissions(discord.utils.get(guild.roles,
name="1BIT"),
read_messages=True,
send_messages=True)
await semester[0].set_permissions(discord.utils.get(guild.roles,
name="2BIT"),
overwrite=None)
await semester[1].set_permissions(discord.utils.get(guild.roles,
name="1BIT"),
read_messages=True,
send_messages=True)
await semester[1].set_permissions(discord.utils.get(guild.roles,
name="2BIT"),
overwrite=None)
await semester[2].set_permissions(discord.utils.get(guild.roles,
name="2BIT"),
read_messages=True,
send_messages=True)
await semester[2].set_permissions(discord.utils.get(guild.roles,
name="3BIT"),
overwrite=None)
await semester[3].set_permissions(discord.utils.get(guild.roles,
name="2BIT"),
read_messages=True,
send_messages=True)
await semester[3].set_permissions(discord.utils.get(guild.roles,
name="3BIT"),
overwrite=None)
await semester[4].set_permissions(discord.utils.get(guild.roles,
name="3BIT"),
read_messages=True,
send_messages=True)
await ctx.send('Holy f**k, všechno se povedlo, '
'tak zase za rok <:Cauec:602052606210211850>')
def countStatus(self, status: str):
return session.query(User).filter(User.status == status).count()
def get_rule(self, guild_id: int, command: str) -> Optional[ACL_rule]:
return (
session.query(ACL_rule)
.filter(ACL_rule.guild_id == guild_id, ACL_rule.command == command)
.one_or_none()
)
def groups(self):
return session.query(RoleGroup).all()
def get_group_by_role(self, role_id: int) -> Optional[ACL_group]:
return session.query(ACL_group).filter(ACL_group.role_id == role_id).one_or_none()
def get_rules(self, guild_id: int) -> Optional[List[ACL_rule]]:
return session.query(ACL_rule).filter(ACL_rule.guild_id == guild_id).all()
def get_group(self, guild_id: int, name: str) -> Optional[ACL_group]:
return (
session.query(ACL_group)
.filter(ACL_group.guild_id == guild_id, ACL_group.name == name)
.one_or_none()
)
def remove_user_constraint(self, constraint_id: int) -> bool:
result = session.query(ACL_rule_user).filter(ACL_rule_user.id == constraint_id).delete()
session.commit()
return result > 0
def get_groups(self, guild_id: int) -> Optional[List[ACL_group]]:
return session.query(ACL_group).filter(ACL_group.guild_id == guild_id).all()
async def update_db(self, ctx, convert_0xit: bool = False):
with open("merlin-latest", "r") as f:
data = f.readlines()
found_people = []
found_logins = []
new_logins = []
login_results = session.query(Valid_person.login).all()
# Use unpacking on results
old_logins = [value for value, in login_results]
for line in data:
line = line.split(":")
login = line[0]
name = line[4].split(",", 1)[0]
try:
year_fields = line[4].split(",")[1].split(" ")
year = " ".join(year_fields if "mail=" not in
year_fields[-1] else year_fields[:-1])
mail = year_fields[-1].replace(
"mail=", "") if "mail=" in year_fields[-1] else None
except IndexError:
continue
if convert_0xit and year.endswith("1r"):
person = session.query(Valid_person).filter(
Valid_person.login == login).one_or_none()
if person is not None and person.year.endswith("0r"):
year = year.replace("1r", "0r")
found_people.append(
Valid_person(login=login, year=year, name=name, mail=mail))
found_logins.append(login)
for login in found_logins:
if login not in old_logins:
new_logins.append(login)
await ctx.send(f"Našel jsem {len(new_logins)} nových loginů.")
for person in found_people:
session.merge(person)
cnt_new = 0
for person in session.query(Valid_person):
if person.login not in found_logins:
try:
# check for muni
int(person.login)
person.year = "MUNI"
except ValueError:
person.year = "dropout"
elif convert_0xit and person.login in new_logins:
if person.year.endswith("1r"):
person.year = person.year.replace("1r", "0r")
cnt_new += 1
session.commit()
await ctx.send("Aktualizace databáze proběhla úspěšně.")
if convert_0xit:
await ctx.send(f"Debug: Našel jsem {cnt_new} nových prvaků.")
def get_group(self, name):
query = session.query(RoleGroup).filter(RoleGroup.name == str(name))
return query.one_or_none()
async def role_check(
self,
ctx,
p_verified: bool = True,
p_move: bool = False,
p_status: bool = True,
p_role: bool = True,
p_zapis: bool = False,
p_debug: bool = True,
):
guild = self.bot.get_guild(config.guild_id)
members = guild.members
verify = disnake.utils.get(guild.roles, name="Verify")
host = disnake.utils.get(guild.roles, name="Host")
bot = disnake.utils.get(guild.roles, name="Bot")
poradce = disnake.utils.get(guild.roles, name="Poradce")
dropout = disnake.utils.get(guild.roles, name="Dropout")
survivor = disnake.utils.get(guild.roles, name="Survivor")
king = disnake.utils.get(guild.roles, name="King")
vut = disnake.utils.get(guild.roles, name="VUT")
dropout_alternatives = [survivor, king]
verified = [
member for member in members if verify in member.roles
and host not in member.roles and bot not in member.roles
and poradce not in member.roles and vut not in member.roles
]
permited = session.query(Permit)
permited_ids = [int(person.discord_ID) for person in permited]
years = [
"0BIT", "1BIT", "2BIT", "3BIT", "4BIT+", "0MIT", "1MIT", "2MIT",
"3MIT+", "PhD+", "Dropout"
]
year_roles = {
year: disnake.utils.get(guild.roles, name=year)
for year in years
}
weird_members = {
year_y: {year_x: []
for year_x in year_roles.values()}
for year_y in year_roles.values()
}
for member in verified:
if member.id not in permited_ids:
if p_verified:
await ctx.send("Ve verified databázi jsem nenašel: " +
utils.generate_mention(member.id))
else:
try:
login = session.query(Permit).filter(
Permit.discord_ID == str(member.id)).one().login
person = session.query(Valid_person).filter(
Valid_person.login == login).one()
except NoResultFound:
continue
except MultipleResultsFound:
await ctx.send(f"{member.id} je v permit databazi vickrat?"
)
continue
if person.status != 0:
if p_status:
await ctx.send("Status nesedí u: " + login)
year = self.verification.transform_year(person.year)
if year is None:
year = "Dropout"
correct_role = disnake.utils.get(guild.roles, name=year)
if correct_role not in member.roles:
for role_name, role in year_roles.items():
if role in member.roles and correct_role in weird_members[
role].keys():
weird_members[role][correct_role].append(member)
break
else:
if correct_role == dropout and not any(
role in member.roles
for role in dropout_alternatives):
await ctx.send(
f"{utils.generate_mention(member.id)} by mel "
f"mit prej `{year}`")
for source_role, target_data in weird_members.items():
for target_role, target_members in target_data.items():
if len(target_members) == 0:
continue
source_year = source_role.name
target_year = target_role.name
target_ids = [member.id for member in target_members]
if (p_zapis
and (("BIT" in source_year and "BIT" in target_year) or
("MIT" in source_year and "MIT" in target_year))
and int(source_year[0]) == int(target_year[0]) + 1):
message_prefix = (
"Vypada ze do dalsiho rocniku se nezapsali "
f"(protoze na merlinovi maji {target_year}): ")
await self.send_masstag_messages(ctx, message_prefix,
target_ids)
elif p_move and (
# presun bakalaru do 1MIT
("BIT" in source_year and target_year == "1MIT")
or target_year == "Dropout"):
await ctx.send(
f"Přesouvám techle {len(target_members)} lidi z "
f"{source_year} do {target_year}:")
await self.send_masstag_messages(ctx, "", target_ids)
if p_debug:
await ctx.send("jk, debug mode")
else:
for member in target_members:
if target_role == dropout and not any(
role in member.roles
for role in dropout_alternatives):
await member.add_roles(target_role)
await member.remove_roles(source_role)
elif p_role:
await ctx.send(
f"Nasel jsem {len(target_members)} lidi kteri maji na merlinovi "
f"{target_year} ale roli {source_year}:")
await self.send_masstag_messages(ctx, "", target_ids)
await ctx.send("Done")
def user_exist(user_id: int) -> bool:
return session.query(
session.query(User).filter(
User.id == str(user_id)).exists()).scalar()
async def role_check(self, ctx, p_verified: bool = True,
p_move: bool = True, p_status: bool = True,
p_role: bool = True, p_muni: bool = True):
guild = self.bot.get_guild(config.guild_id)
members = guild.members
verify = discord.utils.get(guild.roles, name="Verify")
host = discord.utils.get(guild.roles, name="Host")
bot = discord.utils.get(guild.roles, name="Bot")
poradce = discord.utils.get(guild.roles, name="Poradce")
dropout = discord.utils.get(guild.roles, name="Dropout")
muni = discord.utils.get(guild.roles, name="MUNI")
verified = [member for member in members
if verify in member.roles and
host not in member.roles and
bot not in member.roles and
poradce not in member.roles]
if not p_muni:
verified = [member for member in verified
if muni not in member.roles]
permited = session.query(Permit)
permited_ids = [int(person.discord_ID) for person in permited]
years = ["0BIT", "1BIT", "2BIT", "3BIT", "4BIT+",
"0MIT", "1MIT", "2MIT", "3MIT+", "Dropout"]
year_roles = {year: discord.utils.get(guild.roles, name=year) for year in years}
for member in verified:
if member.id not in permited_ids:
if p_verified:
await ctx.send("Ve verified databázi jsem nenašel: " +
utils.generate_mention(member.id))
else:
try:
login = session.query(Permit).\
filter(Permit.discord_ID == str(member.id)).one().login
person = session.query(Valid_person).\
filter(Valid_person.login == login).one()
except NoResultFound:
continue
if person.status != 0:
if p_status:
await ctx.send("Status nesedí u: " + login)
year = self.verification.transform_year(person.year)
correct_role = discord.utils.get(guild.roles, name=year)
if year is not None and correct_role not in member.roles:
if p_move:
for role_name, role in year_roles.items():
if role in member.roles:
await member.add_roles(correct_role)
await member.remove_roles(role)
await ctx.send("Přesouvám: " + member.display_name +
" z " + role_name + " do " + year)
break
else:
await member.add_roles(dropout)
await ctx.send("Přesouvám: " + member.display_name +
" z " + role_name + " do dropout")
elif p_role:
await ctx.send("Nesedí mi role u: " +
utils.generate_mention(member.id) +
", měl by mít roli: " + year)
elif year is None:
if p_move:
for role_name, role in year_roles.items():
if role in member.roles:
await member.add_roles(dropout)
await member.remove_roles(role)
await ctx.send("Přesouvám: " + member.display_name +
" z " + role_name + " do dropout")
break
else:
await member.add_roles(dropout)
await ctx.send("Přesouvám: " + member.display_name +
" z " + role_name + " do dropout")
elif p_role:
await ctx.send("Nesedí mi role u: " +
utils.generate_mention(member.id) +
", má teď ročník: " + person.year)
await ctx.send("Done")
def delete_user(user_id: int):
session.query(User).filter(User.id == str(user_id)).delete()
session.commit()
def countGroup(self, group: str):
return session.query(User).filter(User.group == group).count()
def guild_user_exist(user_id: int, guild_id: int) -> bool:
return session.query(
session.query(GuildUser).filter(
GuildUser.id == str(user_id),
GuildUser.guild_id == str(guild_id)).exists()).scalar()
def getByLogin(self, login: str):
"""Get user from database"""
return session.query(User).filter(User.login == login).one_or_none()
def get_user(self, login: str, status: int = 2):
""""Finds login from database"""
user = (session.query(Valid_person).filter(
Valid_person.login == login,
Valid_person.status == status).one_or_none())
return user
def filterId(self, discord_id: int):
"""Find user in database"""
users = session.query(User).filter(User.discord_id == discord_id).all()
return users
def get_user_by_id(self, discord_ID):
"""Returns user specified by discord ID"""
return (session.query(Valid_person).outerjoin(
Permit, Permit.login == Valid_person.login).filter(
Permit.discord_ID == str(discord_ID)).one_or_none())
def filterLogin(self, login: str):
return session.query(User).filter(User.login == login).all()
def get_user_by_login(self, login: str):
"""Finds login from DB (without status check)"""
user = (session.query(Valid_person).filter(
Valid_person.login == login).one_or_none())
return user
def filterGroup(self, group: str):
return session.query(User).filter(User.group == group).all()
def remove_emoji(self, emoji_id):
session.query(Karma_emoji).filter(
Karma_emoji.emoji_ID == utils.str_emoji_id(emoji_id)).delete()
session.commit()
