hypoxie/krekbot-moderation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
HypoxiE
2025-07-07 00:28:19 +03:00
commit 942365efb2
16 changed files with 2640 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

210
src/cogs/administrators.py Normal file
View File

@@ -0,0 +1,210 @@
import disnake
from disnake.ext import commands
from disnake.ext import tasks
import requests
import numpy as np
import asyncio
import sys
import os
import copy
import datetime
import math
import random
import json
import shutil
def setup(bot):
bot.add_cog(AdminModule(bot))
class AdminModule(commands.Cog):
def __init__(self, client):
self.client = client
self.DataBaseManager = client.DataBaseManager
@commands.Cog.listener()
async def on_ready(self):
print(f'KrekModBot admin module activated')
@commands.slash_command(name="bot_mod_off")
async def BotModOff(self, ctx: disnake.ApplicationCommandInteraction):
if self.client.me in ctx.author.roles:
await ctx.send(embed=disnake.Embed(description=f'Бот отключён', colour=0xff9900), ephemeral=True)
await self.client.BotOff()
else:
await ctx.send(embed=disnake.Embed(description=f'Не допустимо', colour=0xff9900), ephemeral=True)
@commands.slash_command(name="очистка", administrator=True)
async def clear(self, ctx: disnake.AppCmdInter, count: int):
if self.client.me in ctx.author.roles:
await ctx.channel.purge(limit=count)
await ctx.send(embed = disnake.Embed(description = f'очищено {count} сообщений!', colour = 0xff9900), ephemeral=True)
else:
await ctx.send(embed = disnake.Embed(description = f'Ты чего удумал?', colour = 0xff9900), ephemeral=True)
@commands.slash_command(description="Позволяет менять/создавать/удалять ветви", name="правка_ветви", administrator=True)
async def edit_branch(self, ctx: disnake.AppCmdInter, purpose: str = commands.Param(description="Укажите цель этой ветки (например, \"модерация\" или \"администрация\")", name="цель", default=None),
layer: int = commands.Param(description="Укажите слой этой ветки (у ролей нижних слоёв есть власть над верхними)", name="слой", default=None),
branchid: int = commands.Param(description="Необходимо для изменения уже существующей ветви", name="id", default=None),
is_admin: bool = commands.Param(description="Имеют ли пользователи в этой роли права администратора? *(только при создании)", name="администратор", default=False),
is_moder: bool = commands.Param(description="Имеют ли пользователи в этой роли права модератора? *(только при создании)", name="модератор", default=False),
delete_branch: str = commands.Param(description="Вы уверены, что хотите удалить ветвь? Для подтверждения впишите \"уверен\"", name="удаление", default=None)):
if not self.client.me in ctx.author.roles:
await ctx.send(embed = disnake.Embed(description = f'Недостаточно прав', colour = 0xff9900), ephemeral=True)
return 1
async with self.DataBaseManager.session() as session:
if delete_branch == "уверен":
if branchid is None:
await ctx.send(embed = disnake.Embed(description = f'Для удаления ветки необходимо указать её id', colour = 0xff9900))
return 1
async with session.begin():
stmt = self.DataBaseManager.delete(self.DataBaseManager.models['staff_branches'].m).where(self.DataBaseManager.models['staff_branches'].m.id == branchid)
await session.execute(stmt)
await ctx.send(embed = disnake.Embed(description = f'Ветка {branchid} успешно удалена', colour = 0xff9900))
return 0
if branchid is None:
if layer is None or purpose is None:
await ctx.send(embed = disnake.Embed(description = f'Для создания роли необходимо ввести все данные', colour = 0xff9900))
return 1
async with session.begin():
new_branch = self.DataBaseManager.models['staff_branches'].m(layer = layer, purpose = purpose, is_admin = is_admin, is_moder = is_moder)
session.add(new_branch)
await ctx.send(embed = disnake.Embed(description = f'Ветвь \"{purpose}\" успешно создана. Её новый id: {new_branch.id}', colour = 0xff9900))
return 0
else:
async with session.begin():
branch = await session.get(self.DataBaseManager.models['staff_branches'].m, branchid, with_for_update = True)
if branch is None:
await ctx.send(embed = disnake.Embed(description = f'Ветви с таким идентификатором пока не существует', colour = 0xff9900))
return 1
else:
if purpose is None and layer is None:
await ctx.send(embed = disnake.Embed(description = f'Для изменения ветви необходимы новые значения', colour = 0xff9900))
return 1
if not purpose is None:
branch.purpose = purpose
if not layer is None:
branch.layer = layer
await ctx.send(embed = disnake.Embed(description = f'Ветвь \"{branch.purpose}\"({branch.id}) успешно изменена', colour = 0xff9900))
return 0
@commands.slash_command(description="Позволяет менять/создавать/удалять роли в системе персонала", name="правка_роли", administrator=True)
async def edit_role(self, ctx: disnake.AppCmdInter, roleid: str = commands.Param(description="Укажите id роли (используются идентификаторы дискорда)", name="id"),
staffsalary: int = commands.Param(description="Укажите зарплату этой роли", name="зарплата", default=0),
branchid: int = commands.Param(description="Укажите id ветви для этой роли *(только при создании)", name="ветвь", default=None),
layer: int = commands.Param(description="Укажите слой этой роли в ветке (у ролей нижних слоёв есть власть над верхними)", name="слой", default=None),
delete_role: str = commands.Param(description="Вы уверены, что хотите удалить роль из системы? Для подтверждения впишите \"уверен\"", name="удаление", default=None),):
if not self.client.me in ctx.author.roles:
await ctx.send(embed = disnake.Embed(description = f'Недостаточно прав', colour = 0xff9900), ephemeral=True)
return 1
roleid = int(roleid)
staff_roles_model = self.DataBaseManager.models['staff_roles'].m
async with self.DataBaseManager.session() as session:
if delete_role == "уверен":
async with session.begin():
stmt = self.DataBaseManager.delete(staff_roles_model).where(staff_roles_model.id == roleid)
await session.execute(stmt)
await ctx.send(embed = disnake.Embed(description = f'Роль <@&{roleid}> успешно удалена из системы', colour = 0xff9900))
return 0
async with session.begin():
role = await session.get(staff_roles_model, roleid, with_for_update = True)
if not role is None:
if staffsalary != 0:
role.staff_salary = staffsalary
await ctx.send(embed = disnake.Embed(description = f'Зарплата роли <@&{roleid}> успешно изменена на {staffsalary}', colour = 0xff9900))
return 0
elif not layer is None:
role.layer = layer
await ctx.send(embed = disnake.Embed(description = f'Слой роли <@&{roleid}> успешно изменён на {layer}', colour = 0xff9900))
return 0
else:
await ctx.send(embed = disnake.Embed(description = f'Для изменения существующей роли необходимо ввести новые параметры: layer или staffsalary', colour = 0xff9900))
return 1
else:
if branchid is None:
await ctx.send(embed = disnake.Embed(description = f'Для внесения этой роли в систему необходимо указать id ветви', colour = 0xff9900))
return 1
if layer is None:
await ctx.send(embed = disnake.Embed(description = f'Для внесения этой роли в систему необходимо указать слой роли', colour = 0xff9900))
return 1
branch = await session.get(self.DataBaseManager.models['staff_branches'].m, branchid)
if branch is None:
await ctx.send(embed = disnake.Embed(description = f'Ветви с таким id пока не существует', colour = 0xff9900))
return 1
role = staff_roles_model(id = roleid, staff_salary = staffsalary, branch_id = branchid, layer = layer)
session.add(role)
await ctx.send(embed = disnake.Embed(description = f'Роль <@&{roleid}> успешно добавлена в ветвь {branchid}', colour = 0xff9900))
return 0
@commands.slash_command(description="Позволяет создавать/удалять пользователей в системе персонала", name="правка_пользователя", administrator=True)
async def edit_member(self, ctx: disnake.AppCmdInter, userid: str = commands.Param(description="Укажите id пользователя (используются идентификаторы дискорда)", name="id"),
delete_user: str = commands.Param(description="Вы уверены, что хотите удалить пользователя из системы? Для подтверждения впишите \"уверен\"", name="удаление", default=None)):
if not self.client.me in ctx.author.roles:
await ctx.send(embed = disnake.Embed(description = f'Недостаточно прав', colour = 0xff9900), ephemeral=True)
return 1
userid = int(userid)
staff_users_model = self.DataBaseManager.models['staff_users'].m
async with self.DataBaseManager.session() as session:
if delete_user == "уверен":
async with session.begin():
stmt = self.DataBaseManager.delete(staff_users_model).where(staff_users_model.id == userid)
await session.execute(stmt)
await ctx.send(embed = disnake.Embed(description = f'Пользователь <@{userid}> успешно удален из системы', colour = 0xff9900))
member = await self.client.krekchat.fetch_member(userid)
await member.remove_roles(self.client.staff)
return 0
async with session.begin():
user = await session.get(staff_users_model, userid, with_for_update = True)
if user is None:
member = await self.client.krekchat.fetch_member(userid)
await member.add_roles(self.client.staff)
user = staff_users_model(id = userid)
session.add(user)
await ctx.send(embed = disnake.Embed(description = f'Пользователь <@{userid}> успешно добавлен в систему', colour = 0xff9900))
return 0
else:
await ctx.send(embed = disnake.Embed(description = f'Пользователь <@{userid}> уже есть в системе', colour = 0xff9900))
return 1
@commands.slash_command(description="!!ВАЖНО!! ИСПОЛЬЗОВАНИЕ ТОЛЬКО В ЭКСТРЕННЫХ СЛУЧАЯХ! Назначает пользователей на роль", name="назначить_пользователя", administrator=True)
async def appoint_member(self, ctx: disnake.AppCmdInter, userid: str = commands.Param(description="Укажите id пользователя (используются идентификаторы дискорда)", name="пользователь"),
roleid: str = commands.Param(description="Укажите id роли (используются идентификаторы дискорда)", name="роль"),
description: str = commands.Param(description="Описание", name="описание", default=None)):
if not self.client.me in ctx.author.roles:
await ctx.send(embed = disnake.Embed(description = f'Недостаточно прав', colour = 0xff9900), ephemeral=True)
return 1
userid = int(userid)
roleid = int(roleid)
async with self.DataBaseManager.session() as session:
async with session.begin():
user = await session.get(self.DataBaseManager.model_classes['staff_users'], userid)
if user is None:
user = self.DataBaseManager.model_classes['staff_users'](id = userid)
session.add(user)
await session.flush()
user_role = await self.DataBaseManager.model_classes['staff_users_roles'].create_with_auto_branch(session, user_id = userid, role_id = roleid, description = description)
session.add(user_role)
await ctx.send(embed = disnake.Embed(description = f'Пользователю <@{userid}> успешно назначена роль <@&{roleid}>. \n```diff\n- Эта функция не выдаёт роли автоматически, поэтому требуется выдача вручную.```', colour = 0xff9900))
return 0

686
src/cogs/moderators.py Normal file
View File

@@ -0,0 +1,686 @@
import disnake
from disnake.ext import commands
from disnake.ext import tasks
import asyncio
import sys
import os
import copy
import datetime
import math
import random
import json
import shutil
translate = {"textmute":"Текстовый мут", "voicemute":"Голосовой мут", "ban":"Бан", "warning":"Предупреждение",\
"time":"Время", "reason":"Причина", "changenick":"Сменить ник", "reprimand":"Выговор", "newnick":"Новый ник"}
form_to_send = {'punishment_mutes_voice': 'voice_mutes', 'punishment_mutes_text': 'text_mutes', 'punishment_bans': 'bans', 'punishment_warns': 'warns', 'punishment_reprimands': 'reprimand', 'punishment_perms': 'perm'}
count_translate = {"textmute":3, "voicemute":3, "ban":9, "warning":1, "changenick":0, "punishment_mutes_text":3, "punishment_mutes_voice":3, "punishment_bans":9, "punishment_warns":1}
def setup(bot):
bot.add_cog(ModerModule(bot))
class ModerModule(commands.Cog):
def __init__(self, client):
self.client = client
self.DataBaseManager = self.client.DataBaseManager
@commands.Cog.listener()
async def on_ready(self):
print(f'KrekModBot moderation module activated')
@commands.slash_command(name="действие")
async def action_slash(self, ctx: disnake.AppCmdInter, member: disnake.Member):
models = self.client.DataBaseManager.model_classes
DataBaseManager = self.client.DataBaseManager
staff_users_roles_model = self.DataBaseManager.model_classes['staff_users_roles']
staff_users_model = self.DataBaseManager.model_classes['staff_users']
staff_roles_model = self.DataBaseManager.model_classes['staff_roles']
staff_branches_model = self.DataBaseManager.model_classes['staff_branches']
class ActionSelect(disnake.ui.Select):
client = self.client
max_strength_role = self.max_strength_role
def __init__(self, member, reprimand_branches: list, other_on: bool):
self.member=member
placeholder = "Выберите действие"
options = []
for branch in reprimand_branches:
options += [disnake.SelectOption(label=f"Выговор в ветке {branch.purpose}", value=f"reprimand:{branch.id}")]
if other_on:
options += [
disnake.SelectOption(label="Предупреждение", value="warning"),
disnake.SelectOption(label="Войс мут", value="voicemute"),
disnake.SelectOption(label="Текстовый мут", value="textmute"),
disnake.SelectOption(label="Бан", value="ban"),
disnake.SelectOption(label="Сменить ник", value="changenick"),
]
options += [disnake.SelectOption(label="Удалить наказание", value="deletepenalties")]
super().__init__(placeholder = placeholder, min_values = 1, max_values = 1, options = options)
async def callback(self, interaction:disnake.MessageInteraction):
class ActionModal(disnake.ui.Modal):
client = self.client
def __init__(self, title, member):
self.member = member
self.title = title
if title.split(":")[0] == "textmute" or title.split(":")[0] == "voicemute" or title.split(":")[0] == "ban":
components = [
disnake.ui.TextInput(label="Время", placeholder="Например: 1д15ч9мин", custom_id="time", style=disnake.TextInputStyle.short, max_length=100),
disnake.ui.TextInput(label = "Причина", placeholder="Например: правило 1.3" , custom_id="reason", style=disnake.TextInputStyle.paragraph, max_length=100)
]
if title.split(":")[0] == "warning":
components = [
disnake.ui.TextInput(label = "Причина", placeholder="Например: правило 1.3" , custom_id="reason", style=disnake.TextInputStyle.paragraph, max_length=100)
]
if title.split(":")[0] == "reprimand":
components = [
disnake.ui.TextInput(label = "Причина", placeholder="Например: неправомерный бан" , custom_id="reason", style=disnake.TextInputStyle.paragraph, max_length=100)
]
if title.split(":")[0] == "changenick":
components = [
disnake.ui.TextInput(label="Новый ник", placeholder="Например: Humanoid", custom_id="newnick", style=disnake.TextInputStyle.short, max_length=32)
]
super().__init__(title = title, components = components, timeout=300)
async def callback(self, interaction: disnake.Interaction):
async def voicemute(interaction: disnake.MessageInteraction, member: disnake.Member, time, reason):
role = self.client.voice_mute
await member.add_roles(role)
await member.move_to(None)
async with DataBaseManager.session() as session:
async with session.begin():
new_punishment = models['punishment_mutes_voice'](user_id = member.id, reason = reason, time_end = time, time_warn = None, moderator_id = interaction.author.id)
session.add(new_punishment)
async def textmute(interaction: disnake.MessageInteraction, member: disnake.Member, time, reason):
role = self.client.text_mute
await member.add_roles(role)
async with DataBaseManager.session() as session:
async with session.begin():
new_punishment = models['punishment_mutes_text'](user_id = member.id, reason = reason, time_end = time, time_warn = None, moderator_id = interaction.author.id)
session.add(new_punishment)
async def ban(interaction: disnake.MessageInteraction, member: disnake.Member, time, reason):
role = self.client.ban_role
await member.move_to(None)
if time-datetime.datetime.timestamp(datetime.datetime.now())>0:
await member.add_roles(role)
async with DataBaseManager.session() as session:
async with session.begin():
new_punishment = models['punishment_bans'](user_id = member.id, reason = reason, time_end = time, moderator_id = interaction.author.id)
session.add(new_punishment)
return
await member.add_roles(role)
async with DataBaseManager.session() as session:
async with session.begin():
new_punishment = models['punishment_perms'](user_id = member.id, reason = reason, moderator_id = interaction.author.id)
session.add(new_punishment)
for channel in interaction.guild.channels:
if isinstance(channel, disnake.TextChannel):
await channel.purge(limit=10, check=lambda m: m.author==member)
async def warning(interaction: disnake.MessageInteraction, member: disnake.Member, reason):
async with DataBaseManager.session() as session:
async with session.begin():
new_punishment = models['punishment_warns'](user_id = member.id, reason = reason, time_warn = float(self.client.TimeFormater(days = 30)), moderator_id = interaction.author.id)
session.add(new_punishment)
async def reprimand(interaction: disnake.MessageInteraction, member: disnake.Member, branchid, reason):
async with DataBaseManager.session() as session:
async with session.begin():
new_punishment = models['punishment_reprimands'](user_id = member.id, branch_id = branchid, reason = reason, time_warn = float(self.client.TimeFormater(days = 80)), designated_user_id = interaction.author.id)
session.add(new_punishment)
async def changenick(interaction: disnake.MessageInteraction, member: disnake.Member, newnick):
await member.edit(nick=newnick)
await interaction.response.defer(ephemeral=True)
embed = disnake.Embed(title=f"{translate[self.title.split(':')[0]]}", description = f"{self.member.mention} ({self.member.id})")
bans_channel = disnake.utils.get(interaction.guild.channels, id = 1219644103973671035)
warns_channel = disnake.utils.get(interaction.guild.channels, id = 1219644151184887838)
muts_channel = disnake.utils.get(interaction.guild.channels, id = 1219644125469474889)
reprimands_channel = disnake.utils.get(interaction.guild.channels, id = self.client.constants['reprimandlog_channel'])
logs_channel = disnake.utils.get(interaction.guild.channels, id = 490730651629387776)
formated_time = None
reason = ""
newnick = ""
if self.title.split(':')[0] == "reprimand":
embed.add_field(name = 'Ветка', value = self.title.split(':')[1], inline = False)
for key, value in interaction.text_values.items():
if key == "time":
formated_time = self.client.TimeFormater(value)
embed.add_field(name = translate[key], value = str(formated_time), inline = True)
elif key == "reason":
reason = value
embed.add_field(name = translate[key], value = f"```{value}```", inline = False)
elif key == "newnick":
newnick = value
embed.add_field(name = "", value=f"`{self.member.nick!r} ==> {newnick!r}`", inline = False)
else:
embed.add_field(name = translate[key], value = value, inline = False)
embed.set_footer(text = f"{interaction.author.name}\n{interaction.author.id}")
embed.set_thumbnail(url=self.member.avatar)
await self.client.bt_send({"type": "punishment", "options": {"severity": self.title.split(':')[0], "member": self.member.id, "moderator": interaction.author.id}})
if self.title.split(":")[0] == "reprimand":
async with DataBaseManager.session() as session:
async with session.begin():
stmt = (
DataBaseManager.select(models['punishment_reprimands'])
.where(
models['punishment_reprimands'].user_id == self.member.id,
models['punishment_reprimands'].branch_id == int(self.title.split(':')[1])
)
)
result = (await session.execute(stmt)).scalars().all()
await reprimand(interaction, self.member, int(self.title.split(':')[1]), reason)
embed.add_field(name = "Всего выговоров в этой ветке", value = str(len(result)+1), inline = False)
await reprimands_channel.send(embed=embed)
else:
if self.title == "textmute":
await textmute(interaction, self.member, float(formated_time), reason)
await muts_channel.send(embed=embed)
await interaction.author.send("Скопируй и вставь следующее сообщение с прикреплением доказательств в канал \"[mutlog](https://discord.com/channels/1219110919536115802/1219114151566114847)\"!!!")
await interaction.author.send(f"```{self.member.id}/{str(formated_time)}/{reason}```")
elif self.title == "voicemute":
await voicemute(interaction, self.member, float(formated_time), reason)
await muts_channel.send(embed=embed)
await interaction.author.send("Скопируй и вставь следующее сообщение с прикреплением доказательств в канал \"[mutlog](https://discord.com/channels/1219110919536115802/1219114151566114847)\"!!!")
await interaction.author.send(f"```{self.member.id}/{str(formated_time)}/{reason}```")
elif self.title == "ban":
await ban(interaction, self.member, float(formated_time), reason)
await bans_channel.send(embed=embed)
await interaction.author.send("Скопируй и вставь следующее сообщение с прикреплением доказательств в канал \"[banlog](https://discord.com/channels/1219110919536115802/1219110920060407850)\"!!!")
await interaction.author.send(f"```{self.member.id}/{str(formated_time)}/{reason}```")
elif self.title == "warning":
await warning(interaction, self.member, reason)
await warns_channel.send(embed=embed)
await interaction.author.send("Скопируй и вставь следующее сообщение с прикреплением доказательств в канал \"[warnlog](https://discord.com/channels/1219110919536115802/1219129098257956947)\"!!!")
await interaction.author.send(f"```{self.member.id}/{reason}```")
elif self.title == "changenick":
await changenick(interaction, self.member, newnick)
await logs_channel.send(embed=embed)
else:
await logs_channel.send(embed=embed)
counter = 0
async with DataBaseManager.session() as session:
async with session.begin():
for i in ["punishment_mutes_text", "punishment_mutes_voice", "punishment_bans", "punishment_warns"]:
stmt = DataBaseManager.select(models[i]).where(models[i].user_id == self.member.id)
result = (await session.execute(stmt)).scalars().all()
counter += count_translate[i] * len(result)
if counter>=18:
await ban(interaction, self.member, 0, "Набрал больше 18 'очков наказаний'")
await bans_channel.send(embed=disnake.Embed(title=f"Достойное достижение!", description = f"Поздравляем! {self.member.mention}({self.member.id}) наконец набрал целых {counter} очков наказания и получил свою награду: вечный бан!"))
await interaction.edit_original_response(embed=embed)
class DeletePenaltiesSelect(disnake.ui.Select):
client = self.client
max_strength_role = self.max_strength_role
def __init__(self, member):
self.member=member
async def initialization(self, embed):
member = self.member
placeholder = "Выберите наказание для снятия"
options=[]
async with DataBaseManager.session() as session:
async with session.begin():
result = []
stmt = self.max_strength_role(user_id = ctx.author.id, is_moder = True, is_admin = True)
author_is_moderator = (await session.execute(stmt)).first() is not None
stmt = self.max_strength_role(user_id = ctx.author.id, is_admin = True)
author_is_admin = (await session.execute(stmt)).first()
if author_is_admin:
stmt = DataBaseManager.select(models['punishment_reprimands']).where(models['punishment_reprimands'].user_id == member.id)
result += (await session.execute(stmt)).scalars().all()
if author_is_moderator:
stmt = DataBaseManager.select(models['punishment_mutes_text']).where(models['punishment_mutes_text'].user_id == member.id)
result += (await session.execute(stmt)).scalars().all()
stmt = DataBaseManager.select(models['punishment_mutes_voice']).where(models['punishment_mutes_voice'].user_id == member.id)
result += (await session.execute(stmt)).scalars().all()
stmt = DataBaseManager.select(models['punishment_bans']).where(models['punishment_bans'].user_id == member.id)
result += (await session.execute(stmt)).scalars().all()
stmt = DataBaseManager.select(models['punishment_warns']).where(models['punishment_warns'].user_id == member.id)
result += (await session.execute(stmt)).scalars().all()
stmt = DataBaseManager.select(models['punishment_perms']).where(models['punishment_perms'].user_id == member.id)
result += (await session.execute(stmt)).scalars().all()
result = sorted(result, key=lambda a: a.time_begin, reverse=True)
for penalt in result:
match penalt.get_table_name():
case 'punishment_mutes_text':
embed.add_field(name = f"{penalt.id} : Текстовый мут", value = f"Заканчивается {'<t:{time_end}:f>'.format(time_end = int(penalt.time_end)) if penalt.time_warn is None else '<t:{time_warn}:f> (предупреждение)'.format(time_warn = int(penalt.time_warn))}\n```{penalt.reason}```", inline = False)
options.append(disnake.SelectOption(label=f"{penalt.id}) Текстовый мут", value=f"{penalt.get_table_name()}:{member.id}:{penalt.id}"))
case 'punishment_mutes_voice':
embed.add_field(name = f"{penalt.id} : Голосовой мут", value = f"Заканчивается {'<t:{time_end}:f>'.format(time_end = int(penalt.time_end)) if penalt.time_warn is None else '<t:{time_warn}:f> (предупреждение)'.format(time_warn = int(penalt.time_warn))}\n```{penalt.reason}```", inline = False)
options.append(disnake.SelectOption(label=f"{penalt.id}) Голосовой мут", value=f"{penalt.get_table_name()}:{member.id}:{penalt.id}"))
case 'punishment_bans':
embed.add_field(name = f"{penalt.id} : Бан", value = f"Заканчивается {'<t:{time_end}:f>'.format(time_end = int(penalt.time_end)) if not penalt.time_end is None else 'никогда (предупреждение)'}\n```{penalt.reason}```", inline = False)
options.append(disnake.SelectOption(label=f"{penalt.id}) Бан", value=f"{penalt.get_table_name()}:{member.id}:{penalt.id}"))
case 'punishment_warns':
embed.add_field(name = f"{penalt.id} : Предупреждение", value = f"Заканчивается <t:{int(penalt.time_warn)}:f>\n```{penalt.reason}```", inline = False)
options.append(disnake.SelectOption(label=f"{penalt.id}) Предупреждение", value=f"{penalt.get_table_name()}:{member.id}:{penalt.id}"))
case 'punishment_reprimands':
embed.add_field(name = f"{penalt.id} : Выговор", value = f"Заканчивается <t:{int(penalt.time_warn)}:f>\n```{penalt.reason}```", inline = False)
options.append(disnake.SelectOption(label=f"{penalt.id}) Выговор", value=f"{penalt.get_table_name()}:{member.id}:{penalt.id}"))
case 'punishment_perms':
embed.add_field(name = f"{penalt.id} : Вечный бан", value = f"```{penalt.reason}```", inline = False)
options.append(disnake.SelectOption(label=f"{penalt.id}) Вечный бан", value=f"{penalt.get_table_name()}:{member.id}:{penalt.id}"))
if len(options)==0:
embed.add_field(name = f"Наказаний нет", value = f" ", inline = False)
options.append(disnake.SelectOption(label="Наказаний нет"))
super().__init__(placeholder = placeholder, min_values = 1, max_values = 1, options = options)
return self
async def callback(self, interaction:disnake.MessageInteraction):
values = interaction.values[0]
try:
pentype, member, penaltid = values.split(":")
except ValueError:
return
if values:
logs_channel = disnake.utils.get(interaction.guild.channels, id = 490730651629387776)
async with DataBaseManager.session() as session:
async with session.begin():
stmt = DataBaseManager.select(models[pentype]).where(
DataBaseManager.and_(
models[pentype].id == int(penaltid),
models[pentype].user_id == int(member)
)
).with_for_update()
result = (await session.execute(stmt)).scalars().first()
await session.delete(result)
if pentype=="punishment_perms" or pentype=="punishment_bans":
await self.member.remove_roles(self.client.ban_role)
await self.client.bt_send({"type": "unpunishment", "options": {"severity": "ban", "member": int(member)}})
elif pentype=="punishment_mutes_text":
await self.member.remove_roles(self.client.text_mute)
await self.client.bt_send({"type": "unpunishment", "options": {"severity": "textmute", "member": int(member)}})
elif pentype=="punishment_mutes_voice":
await self.member.remove_roles(self.client.voice_mute)
await self.client.bt_send({"type": "unpunishment", "options": {"severity": "voicemute", "member": int(member)}})
elif pentype=="punishment_reprimands":
await self.client.bt_send({"type": "unpunishment", "options": {"severity": "reprimand", "member": int(member)}})
elif pentype=="punishment_warns":
await self.client.bt_send({"type": "unpunishment", "options": {"severity": "warning", "member": int(member)}})
view = disnake.ui.View(timeout=30)
embed = disnake.Embed(title="Выберите наказание для снятия", description = f"{self.member.mention}\n({self.member.id})", colour = 0x008000)
view.add_item(await DeletePenaltiesSelect(self.member).initialization(embed))
await interaction.response.edit_message(embed = embed, view=view)
await interaction.followup.send(embed = disnake.Embed(description = f"Наказание {pentype} успешно аннулировано!", colour = 0x008000), ephemeral=True)
await logs_channel.send(embed = disnake.Embed(description = f"{interaction.author.mention}({interaction.author.id}) успешно аннулировал наказание {pentype}({penaltid}) у пользователя {member}", colour = 0x008000),)
if "textmute" in self.values[0] or "voicemute" in self.values[0] or "ban" in self.values[0] or\
"warning" in self.values[0] or "changenick" in self.values[0] or "reprimand" in self.values[0]:
modal = ActionModal(self.values[0], self.member)
await interaction.response.send_modal(modal)
elif "deletepenalties" in self.values[0]:
view = disnake.ui.View(timeout=30)
embed = disnake.Embed(title="Выберите наказание для снятия", description = f"{self.member.mention}\n({self.member.id})", colour = 0x008000)
view.add_item(await DeletePenaltiesSelect(self.member).initialization(embed))
await interaction.response.send_message(embed = embed, ephemeral=True, view=view)
await ctx.response.defer(ephemeral=True)
async with self.DataBaseManager.session() as session:
stmt = self.max_strength_role(ctx.author.id)
author_strenght = (await session.execute(stmt)).first()
if author_strenght is None:
await ctx.edit_original_message(embed = disnake.Embed(description = f"Вы должны иметь должность в персонале полей, чтобы действовать", colour = 0xff9900))
return
stmt = (
self.DataBaseManager.select(staff_users_roles_model)
.options(
self.DataBaseManager.joinedload(staff_users_roles_model.role),
self.DataBaseManager.joinedload(staff_users_roles_model.branch)
)
.where(staff_users_roles_model.user_id == member.id)
)
member_roles = (await session.execute(stmt)).scalars().all()
stmt = (
self.DataBaseManager.select(staff_users_roles_model.role_id)
.where(staff_users_roles_model.user_id == ctx.author.id)
)
author_roles = set((await session.execute(stmt)).scalars().all())
reprimand_branches = []
for role in member_roles:
stmt = (
self.DataBaseManager.select(staff_roles_model.id)
.join(staff_branches_model, staff_roles_model.branch_id == staff_branches_model.id)
.where(
self.DataBaseManager.tuple_(staff_branches_model.layer, staff_roles_model.layer) < (role.branch.layer, role.role.layer)
)
.order_by(
staff_branches_model.layer.asc(),
staff_roles_model.layer.asc()
)
)
grand_roles = set((await session.execute(stmt)).scalars().all())
if bool(author_roles & grand_roles):
reprimand_branches += [role.branch]
stmt = self.max_strength_role(ctx.author.id, is_moder = True, is_admin = True)
author_is_moderator = (await session.execute(stmt)).all()
stmt = self.max_strength_role(member.id, is_moder = True, is_admin = True)
member_is_moderator = (await session.execute(stmt)).all()
class View(disnake.ui.View):
async def on_timeout(self):
await ctx.edit_original_message(view=None)
if (not reprimand_branches) and (not ((not member_is_moderator) and author_is_moderator)):
await ctx.edit_original_message(embed = disnake.Embed(description = f"Вы ничего не можете сделать этому пользователю", colour = 0xff9900))
return
embed = disnake.Embed(title="Выберите действие", description = f"{member.mention}\n({member.id})", colour = 0x008000)
embed.set_thumbnail(url=member.avatar)
view = View(timeout=30)
view.add_item(ActionSelect(member = member, reprimand_branches = reprimand_branches, other_on = (not member_is_moderator) and author_is_moderator))
await ctx.edit_original_message(embed = embed, view=view)
'''
Продвижения и т.п.
'''
def max_strength_role(self, user_id: int, branch_ids: list = [], is_admin: bool = False, is_moder: bool = False):
staff_users_roles_model = self.DataBaseManager.model_classes['staff_users_roles']
staff_users_model = self.DataBaseManager.model_classes['staff_users']
staff_roles_model = self.DataBaseManager.model_classes['staff_roles']
staff_branches_model = self.DataBaseManager.model_classes['staff_branches']
stmt = (
self.DataBaseManager.select(staff_branches_model.layer, staff_roles_model.layer)
.select_from(staff_users_roles_model)
.join(staff_users_model, staff_users_roles_model.user_id == staff_users_model.id)
.join(staff_roles_model, staff_users_roles_model.role_id == staff_roles_model.id)
.join(staff_branches_model, staff_roles_model.branch_id == staff_branches_model.id)
.order_by(
staff_branches_model.layer.asc(),
staff_roles_model.layer.asc()
)
)
if is_admin or is_moder or branch_ids:
stmt = stmt.where(
self.DataBaseManager.and_(
self.DataBaseManager.or_(
staff_branches_model.id.in_(branch_ids),
staff_branches_model.is_admin == is_admin if is_admin else self.DataBaseManager.false(),
staff_branches_model.is_moder == is_moder if is_moder else self.DataBaseManager.false()
),
staff_users_model.id == user_id
)
)
else:
stmt = stmt.where(
staff_users_model.id == user_id
)
return stmt
async def promotions_add_remove_role(self, ctx, userid, add_roleid = None, remove_roleid = None):
krekchat = await self.client.fetch_guild(self.client.krekchat.id)
member = await krekchat.fetch_member(userid)
if not add_roleid is None:
add_role = await krekchat.fetch_role(add_roleid)
try:
await member.add_roles(add_role)
except disnake.errors.Forbidden:
await ctx.channel.send(ctx.author.mention, embed = disnake.Embed(description = f'Недостаточно прав. Пользователю {member.mention} необходимо ручное добавление роли {add_role.mention}', colour = 0xff9900))
if not remove_roleid is None:
remove_role = await krekchat.fetch_role(remove_roleid)
try:
await member.remove_roles(remove_role)
except disnake.errors.Forbidden:
await ctx.channel.send(ctx.author.mention, embed = disnake.Embed(description = f'Недостаточно прав. Пользователю {member.mention} необходимо ручное удаление роли {remove_role.mention}', colour = 0xff9900))
@commands.slash_command(description="Позволяет повысить пользователя в указанной ветке", name="повысить", administrator=True)
async def promote(self, ctx: disnake.AppCmdInter, branchid: int = commands.Param(description="Укажите id ветви", name="ветвь", default = None),
userid: str = commands.Param(description="Укажите id пользователя (используются идентификаторы дискорда)", name="пользователь")):
userid = int(userid)
async with self.DataBaseManager.session() as session:
async with session.begin():
staff_users_roles_model = self.DataBaseManager.model_classes['staff_users_roles']
staff_users_model = self.DataBaseManager.model_classes['staff_users']
staff_roles_model = self.DataBaseManager.model_classes['staff_roles']
staff_branches_model = self.DataBaseManager.model_classes['staff_branches']
if branchid is None:
stmt = (
self.DataBaseManager.select(staff_users_roles_model)
.options(
self.DataBaseManager.selectinload(staff_users_roles_model.role)
.selectinload(staff_roles_model.branch)
)
.where(
staff_users_roles_model.user_id == userid
)
)
user_roles = (await session.execute(stmt)).scalars().all()
if len(user_roles) != 1:
await ctx.send(embed = disnake.Embed(description = f'Для данной операции необходимо уточнение id ветки!', colour = 0xff9900))
return 1
else:
branchid = user_roles[0].role.branch.id
stmt = self.max_strength_role(user_id = ctx.author.id, branch_ids = [branchid], is_admin = True)
author_upper_role = (await session.execute(stmt)).first()
stmt = self.max_strength_role(user_id = userid, branch_ids = [branchid])
member_upper_role = (await session.execute(stmt)).first()
if author_upper_role is None or ((not member_upper_role is None) and author_upper_role >= member_upper_role):
await ctx.send(embed = disnake.Embed(description = f'Вы должны быть выше должности, на которую назначаете пользователя', colour = 0xff9900))
return 1
stmt = (
self.DataBaseManager.select(staff_roles_model)
.options(
self.DataBaseManager.selectinload(staff_roles_model.branch)
)
.where(staff_roles_model.branch_id == branchid)
.order_by(staff_roles_model.layer.desc())
)
branch_roles = (await session.execute(stmt)).scalars().all()
stmt = (
self.DataBaseManager.select(staff_users_roles_model)
.join(staff_users_model, staff_users_roles_model.user_id == staff_users_model.id)
.join(staff_roles_model, staff_users_roles_model.role_id == staff_roles_model.id)
.join(staff_branches_model, staff_roles_model.branch_id == staff_branches_model.id)
.options(
self.DataBaseManager.contains_eager(staff_users_roles_model.user),
self.DataBaseManager.contains_eager(staff_users_roles_model.role)
.contains_eager(staff_roles_model.branch)
)
.where(
self.DataBaseManager.and_(
staff_branches_model.id == branchid,
staff_users_model.id == userid
)
)
).with_for_update()
member_role = (await session.execute(stmt)).scalars().first()
if member_role is not None:
member_role_index = next((i for i, role in enumerate(branch_roles) if role.id == member_role.role.id), None)
if member_role_index + 1 >= len(branch_roles):
await ctx.send(embed = disnake.Embed(description = f'Этот пользователь уже находится на самой высокой должности в данной ветви', colour = 0xff9900))
return 1
target_role = branch_roles[member_role_index + 1]
if author_upper_role >= (target_role.branch.layer, target_role.layer):
await ctx.send(embed = disnake.Embed(description = f'Вы должны быть выше должности, на которую назначаете пользователя', colour = 0xff9900))
return 1
previous_role_id = member_role.role_id
member_role.role_id = target_role.id
await ctx.send(embed = disnake.Embed(description = f'Пользователь <@{userid}> успешно назначен на роль <@&{target_role.id}>', colour = 0xff9900))
await self.promotions_add_remove_role(ctx, userid, add_roleid = target_role.id, remove_roleid = previous_role_id)
return 0
else:
member_check = await session.get(staff_users_model, userid)
if member_check is None:
await ctx.send(embed = disnake.Embed(description = f'Необходимо изначально зарегистрировать пользователя, попросите разработчика использовать \"/правка_пользователя\"', colour = 0xff9900))
return 1
member_role_index = 0
if member_role_index >= len(branch_roles):
await ctx.send(embed = disnake.Embed(description = f'В данной ветви пока нет ролей', colour = 0xff9900))
return 1
target_role = branch_roles[member_role_index]
if author_upper_role >= (target_role.branch.layer, target_role.layer):
await ctx.send(embed = disnake.Embed(description = f'Вы должны быть выше должности, на которую назначаете пользователя', colour = 0xff9900))
return 1
user_role = await staff_users_roles_model.create_with_auto_branch(session, user_id = userid, role_id = target_role.id)
session.add(user_role)
await ctx.send(embed = disnake.Embed(description = f'Пользователь <@{userid}> успешно назначен на роль <@&{target_role.id}>', colour = 0xff9900))
await self.promotions_add_remove_role(ctx, userid, add_roleid = target_role.id)
return 0
@commands.slash_command(description="Позволяет понизить пользователя в указанной ветке", name="понизить", administrator=True)
async def demote(self, ctx: disnake.AppCmdInter, branchid: int = commands.Param(description="Укажите id ветви", name="ветвь", default = None),
userid: str = commands.Param(description="Укажите id пользователя (используются идентификаторы дискорда)", name="пользователь")):
userid = int(userid)
async with self.DataBaseManager.session() as session:
async with session.begin():
staff_users_roles_model = self.DataBaseManager.model_classes['staff_users_roles']
staff_users_model = self.DataBaseManager.model_classes['staff_users']
staff_roles_model = self.DataBaseManager.model_classes['staff_roles']
staff_branches_model = self.DataBaseManager.model_classes['staff_branches']
if branchid is None:
stmt = (
self.DataBaseManager.select(staff_users_roles_model)
.options(
self.DataBaseManager.selectinload(staff_users_roles_model.role)
.selectinload(staff_roles_model.branch)
)
.where(
staff_users_roles_model.user_id == userid
)
)
user_roles = (await session.execute(stmt)).scalars().all()
if len(user_roles) != 1:
await ctx.send(embed = disnake.Embed(description = f'Для данной операции необходимо уточнение id ветки!', colour = 0xff9900))
return 1
else:
branchid = user_roles[0].role.branch.id
stmt = self.max_strength_role(user_id = ctx.author.id, branch_ids = [branchid], is_admin = True)
author_upper_role = (await session.execute(stmt)).first()
stmt = self.max_strength_role(user_id = userid, branch_ids = [branchid])
member_upper_role = (await session.execute(stmt)).first()
if author_upper_role is None or ((not member_upper_role is None) and author_upper_role >= member_upper_role):
await ctx.send(embed = disnake.Embed(description = f'Вы должны быть выше пользователя в должности', colour = 0xff9900))
return 1
stmt = (
self.DataBaseManager.select(staff_roles_model)
.options(
self.DataBaseManager.selectinload(staff_roles_model.branch)
)
.where(staff_roles_model.branch_id == branchid)
.order_by(staff_roles_model.layer.desc())
)
branch_roles = (await session.execute(stmt)).scalars().all()
stmt = (
self.DataBaseManager.select(staff_users_roles_model)
.join(staff_users_model, staff_users_roles_model.user_id == staff_users_model.id)
.join(staff_roles_model, staff_users_roles_model.role_id == staff_roles_model.id)
.join(staff_branches_model, staff_roles_model.branch_id == staff_branches_model.id)
.options(
self.DataBaseManager.contains_eager(staff_users_roles_model.user),
self.DataBaseManager.contains_eager(staff_users_roles_model.role)
.contains_eager(staff_roles_model.branch)
)
.where(
self.DataBaseManager.and_(
staff_branches_model.id == branchid,
staff_users_model.id == userid
)
)
).with_for_update()
member_role = (await session.execute(stmt)).scalars().first()
if member_role is not None:
member_role_index = next((i for i, role in enumerate(branch_roles) if role.id == member_role.role.id), None)
if member_role_index == 0:
stmt = (
self.DataBaseManager.select(staff_users_roles_model)
.where(staff_users_roles_model.user_id == userid)
)
result = (await session.execute(stmt)).scalars().all()
await self.promotions_add_remove_role(ctx, userid, remove_roleid = member_role.role_id)
if len(result) <= 1:
stmt = self.DataBaseManager.delete(staff_users_model).where(staff_users_model.id == userid)
await session.execute(stmt)
await ctx.send(embed = disnake.Embed(description = f'Пользователь <@{userid}> полностью удалён из системы', colour = 0xff9900))
await self.promotions_add_remove_role(ctx, userid, remove_roleid = self.client.staff.id)
return 0
else:
await session.delete(member_role)
await ctx.send(embed = disnake.Embed(description = f'Пользователь <@{userid}> снят со всех должностей в ветви {branchid}', colour = 0xff9900))
return 0
target_role = branch_roles[member_role_index - 1]
previous_role_id = member_role.role_id
member_role.role_id = target_role.id
await ctx.send(embed = disnake.Embed(description = f'Пользователь <@{userid}> успешно понижен до роли <@&{target_role.id}> в ветви {branchid}', colour = 0xff9900))
await self.promotions_add_remove_role(ctx, userid, add_roleid = target_role.id, remove_roleid = previous_role_id)
return 0
else:
await ctx.send(embed = disnake.Embed(description = f'Данный пользователь не имеет роли в ветке {branchid}', colour = 0xff9900))
return 1

14
src/cogs/resetsupcommands.py Normal file
View File

@@ -0,0 +1,14 @@
import disnake
from disnake.ext import commands
def setup(bot: commands.Bot):
bot.add_cog(ExampleCog(bot))
print("ExampleCog загружен!")
class ExampleCog(commands.Cog):
def __init__(self, bot: commands.Bot):
self.bot = bot
@commands.slash_command(name="ping", description="Проверка бота на работоспособность")
async def ping(self, inter: disnake.ApplicationCommandInteraction):
await inter.response.send_message(f"Понг! {round(self.bot.latency * 1000)}мс")

280
src/cogs/users.py Normal file
View File

@@ -0,0 +1,280 @@
import disnake
from disnake.ext import commands
from disnake.ext import tasks
import requests
import numpy as np
import asyncio
import sys
import os
import copy
import datetime
import math
import random
import json
import shutil
def setup(bot):
bot.add_cog(UIModule(bot))
class UIModule(commands.Cog):
def __init__(self, client):
self.client = client
self.DataBaseManager = self.client.DataBaseManager
@commands.Cog.listener()
async def on_ready(self):
print(f'KrekModBot UI module activated')
@commands.slash_command(description="Показывает действительные наказания пользователя", name="наказания")
async def penalties(self, ctx: disnake.AppCmdInter, member: disnake.Member = None):
models = self.client.DataBaseManager.model_classes
if not member:
member = ctx.author
embed = disnake.Embed(title="Наказания", description = f"{member.mention}", colour = 0x008000)
embed.set_thumbnail(url=member.avatar)
async with self.DataBaseManager.session() as session:
async with session.begin():
stmt = self.DataBaseManager.select(models['punishment_mutes_text']).where(models['punishment_mutes_text'].user_id == member.id)
result = (await session.execute(stmt)).scalars().all()
stmt = self.DataBaseManager.select(models['punishment_mutes_voice']).where(models['punishment_mutes_voice'].user_id == member.id)
result += (await session.execute(stmt)).scalars().all()
stmt = self.DataBaseManager.select(models['punishment_bans']).where(models['punishment_bans'].user_id == member.id)
result += (await session.execute(stmt)).scalars().all()
stmt = self.DataBaseManager.select(models['punishment_warns']).where(models['punishment_warns'].user_id == member.id)
result += (await session.execute(stmt)).scalars().all()
stmt = self.DataBaseManager.select(models['punishment_reprimands']).where(models['punishment_reprimands'].user_id == member.id)
result += (await session.execute(stmt)).scalars().all()
stmt = self.DataBaseManager.select(models['punishment_perms']).where(models['punishment_perms'].user_id == member.id)
result += (await session.execute(stmt)).scalars().all()
result = sorted(result, key=lambda a: a.time_begin, reverse=True)
for penalt in result:
match penalt.get_table_name():
case 'punishment_mutes_text':
embed.add_field(name = f"Текстовый мут", value = f"Заканчивается {'<t:{time_end}:f>'.format(time_end = int(penalt.time_end)) if penalt.time_warn is None else '<t:{time_warn}:f> (предупреждение)'.format(time_warn = int(penalt.time_warn))}\n```{penalt.reason}```", inline = False)
case 'punishment_mutes_voice':
embed.add_field(name = f"Голосовой мут", value = f"Заканчивается {'<t:{time_end}:f>'.format(time_end = int(penalt.time_end)) if penalt.time_warn is None else '<t:{time_warn}:f> (предупреждение)'.format(time_warn = int(penalt.time_warn))}\n```{penalt.reason}```", inline = False)
case 'punishment_bans':
embed.add_field(name = f"Бан", value = f"Заканчивается {'<t:{time_end}:f>'.format(time_end = int(penalt.time_end)) if not penalt.time_end is None else 'никогда (предупреждение)'}\n```{penalt.reason}```", inline = False)
case 'punishment_warns':
embed.add_field(name = f"Предупреждение", value = f"Заканчивается <t:{int(penalt.time_warn)}:f>\n```{penalt.reason}```", inline = False)
case 'punishment_reprimands':
embed.add_field(name = f"Выговор", value = f"Заканчивается <t:{int(penalt.time_warn)}:f>\n```{penalt.reason}```", inline = False)
case 'punishment_perms':
embed.add_field(name = f"Вечный бан", value = f"```{penalt.reason}```", inline = False)
if len(embed.fields)==0:
embed.add_field(name = f"Наказаний нет", value = f"", inline = False)
await ctx.response.send_message(embed = embed)
@commands.slash_command(description="Подайте жалобу на нарушение правил сервера или действия модератора", name="жалоба")
async def report(self, ctx: disnake.AppCmdInter, member: disnake.Member = commands.Param(description="На кого хотите подать жалобу?", name="пользователь"), reason: str = commands.Param(description="Кратко опишите причину жалобы", name="причина")):
async def ReportCallback(ctx, member, report_message, reason, embed, mentions, mod):
async def AcceptCallback(report_message, member, embed, mod, call, channel):
if call.author == mod.author:
await channel.delete()
embed.set_footer(text = f"Рассмотрено в пользу исца\n{mod.author.name} ({mod.author.id})")
embed.colour=0x008000
await report_message.edit(content = "", embed=embed, view=None)
await member.send(embed = disnake.Embed(title=f"", description = f"После разбора нарушения модератор {mod.author.mention} признал вас виновным", colour = 0xff9900))
await self.client.bt_send({"type": "complaint", "options": {"accepted": True, "attack_member": ctx.author.id, "defence_member": member.id, "moderator": mod.author.id}})
else:
await call.send(embed = disnake.Embed(title=f"", description = f"Только судья может использовать эти команды", colour = 0xff9900), ephemeral=True)
async def DenyCallback(report_message, member, embed, mod, call, channel):
if call.author == mod.author:
await channel.delete()
embed.set_footer(text = f"Рассмотрено в пользу ответчика\n{mod.author.name} ({mod.author.id})")
embed.colour=0x008000
await report_message.edit(content = "", embed=embed, view=None)
#await member.send(embed = disnake.Embed(title=f"", description = f"После разбора нарушения модератор {mod.author.mention} признал вас невиновным", colour = 0xff9900))
await self.client.bt_send({"type": "complaint", "options": {"accepted": False, "attack_member": ctx.author.id, "defence_member": member.id, "moderator": mod.author.id}})
else:
await call.send(embed = disnake.Embed(title=f"", description = f"Только судья может использовать эти команды", colour = 0xff9900), ephemeral=True)
class AttackClass:
def __init__(self, member, channel, mod):
self.member=member
self.channel=channel
self.mod=mod
self.permatt=True
async def callback(self, mod):
if mod.author == self.mod.author:
await self.channel.set_permissions(self.member, read_messages = True, read_message_history=True, send_messages=self.permatt) #read_messages=self.permatt
await mod.send(embed = disnake.Embed(title=f"", description = f"{self.member.mention}-{'право ответа включено' if self.permatt else 'право ответа выключено'}", colour = 0x008000), ephemeral=True)
self.permatt=not self.permatt
else:
await mod.send(embed = disnake.Embed(title=f"", description = f"Только судья может использовать эти команды", colour = 0xff9900), ephemeral=True)
class DefenceClass:
def __init__(self, member, channel, mod):
self.member=member
self.channel=channel
self.mod=mod
self.permdef=True
async def callback(self, mod):
if mod.author == self.mod.author:
await self.channel.set_permissions(self.member, read_messages = True, read_message_history=True, send_messages=self.permdef) #read_messages=self.permdef
await mod.send(embed = disnake.Embed(title=f"", description = f"{self.member.mention}-{'право ответа включено' if self.permdef else 'право ответа выключено'}", colour = 0x008000), ephemeral=True)
self.permdef=not self.permdef
else:
await mod.send(embed = disnake.Embed(title=f"", description = f"Только судья может использовать эти команды", colour = 0xff9900), ephemeral=True)
if not any(i.mention in mentions for i in mod.author.roles):
await mod.send(embed = disnake.Embed(description = f"Вы не можете принять этот репорт", colour = 0xff9900), ephemeral=True)
return
if mod.author == ctx.author:
await mod.send(embed = disnake.Embed(description = f"Вы не можете принять свой же репорт", colour = 0xff9900), ephemeral=True)
return
embed.set_footer(text = f"Принято\n{mod.author.name} ({mod.author.id})")
embed.colour=0x008000
await report_message.edit(content = "", embed=embed, view=None)
parsing_channel = await ctx.guild.create_text_channel(
name=f"⚠️Жалоба от {ctx.author.name} на {member}",
overwrites = {ctx.author: disnake.PermissionOverwrite(read_messages=True, send_messages=False, read_message_history=True, attach_files=True),
mod.author: disnake.PermissionOverwrite(read_messages=True, send_messages=True, read_message_history=True, attach_files=True),
member: disnake.PermissionOverwrite(read_messages=True, send_messages=False, read_message_history=True, attach_files=True),
self.client.everyone: disnake.PermissionOverwrite(read_messages=False, send_messages=False, read_message_history=False)},
category=ctx.guild.get_channel(1220744958961778850)
)
view = disnake.ui.View(timeout=86400)
btnatt = disnake.ui.Button(label="⚔️", style=disnake.ButtonStyle.primary)
view.add_item(btnatt)
btndef = disnake.ui.Button(label="⚰️", style=disnake.ButtonStyle.primary)
view.add_item(btndef)
btnacc = disnake.ui.Button(label="✅", style=disnake.ButtonStyle.primary)
view.add_item(btnacc)
btnden = disnake.ui.Button(label="❌", style=disnake.ButtonStyle.primary)
view.add_item(btnden)
attack = AttackClass(ctx.author, parsing_channel, mod)
defence = DefenceClass(member, parsing_channel, mod)
pin = await parsing_channel.send( f"{mod.author.mention}" ,embed = disnake.Embed(title=f"Жалоба", description = f"Вы вызвались судить {member.mention} по жалобе от {ctx.author.mention}\n\
⚔️ - Дать {ctx.author.mention} право ответа\n\
⚰️ - Дать {member.mention} право ответа\n\
✅ - Виновен\n\
❌ - Невиновен\n\
Перед закрытием дела убедитесь, что сохранили все доказательства", colour = 0x008000), view=view)
btnatt.callback = lambda mod: attack.callback(mod)
btndef.callback = lambda mod: defence.callback(mod)
btnacc.callback = lambda call: AcceptCallback(report_message, member, embed, mod, call, parsing_channel)
btnden.callback = lambda call: DenyCallback(report_message, member, embed, mod, call, parsing_channel)
await pin.pin()
if member==ctx.author:
await ctx.send(embed = disnake.Embed(description = f'Нельзя подать жалобу на самого себя!', colour = 0xFF4500), ephemeral=True)
return
mentions = []
report_channel = disnake.utils.get(ctx.guild.channels, id = 1219644036378394746)
highest = [i for i in self.client.hierarchy if i in member.roles][0]
for i in range(0, self.client.hierarchy.index(highest)):
mentions.append(f"{self.client.hierarchy[i].mention}")
if len(mentions)==0:
mentions.append(f"{self.client.me.mention}")
report_embed = disnake.Embed(title=f"**Жалоба**", colour = 0xDC143C)
report_embed.add_field(name=f"Обвинитель: ", value = f"{ctx.author.mention}\n({ctx.author.id})", inline=True)
report_embed.add_field(name=f"Обвиняемый: ", value = f"{member.mention}\n({member.id})", inline=True)
report_embed.add_field(name=f"Причина: ", value = f"```{reason}```", inline=False)
view = disnake.ui.View(timeout=86400)
btn = disnake.ui.Button(label="✅", style=disnake.ButtonStyle.primary)
view.add_item(btn)
report_embed.set_thumbnail(url=member.avatar)
report_message = await report_channel.send(", ".join(mentions), embed = report_embed, view=view)
btn.callback = lambda mod: ReportCallback(ctx,member,report_message,reason,report_embed,mentions,mod)
await ctx.send(embed = disnake.Embed(description = f'Жалоба на {member.mention} успешно подана', colour = 0x008000), ephemeral=True)
'''
Иерархия
'''
@commands.slash_command(description="Показывает весь персонал, по ролям и веткам", name="иерархия", administrator=True)
async def hierarchy(self, ctx: disnake.AppCmdInter, branchid: int = commands.Param(description="Укажите id ветки, в которой вам нужна иерархия", name="ветвь", default=None),
devmod: bool = commands.Param(description="Показывать подробную информацию?", name="devmode", default=False)):
async with self.DataBaseManager.session() as session:
async with session.begin():
if branchid is None:
stmt = (
self.DataBaseManager.select(self.DataBaseManager.model_classes['staff_branches'])
.options(
self.DataBaseManager.selectinload(self.DataBaseManager.model_classes['staff_branches'].roles)
)
.order_by(
self.DataBaseManager.model_classes['staff_branches'].layer.asc()
)
)
branches = (await session.execute(stmt)).scalars().all()
for branch in branches:
branch.roles.sort(key=lambda role: role.layer)
embed = disnake.Embed(title = f"", description = f"# Общая иерархия\n", colour = 0xff9900)
for branchcounter, branch in enumerate(branches, start=1):
embed.description += f"## {branchcounter}) {branch.purpose}"
if devmod:
embed.description += f" id:({branch.id}) layer:({branch.layer})"
embed.description += "\n"
for rolecounter, role in enumerate(branch.roles, start=1):
embed.description += f"### {rolecounter}. <@&{role.id}>"
if devmod:
embed.description += f" layer:({role.layer})"
embed.description += "\n"
await ctx.send(embed = embed)
else:
branch = await session.get(self.DataBaseManager.model_classes['staff_branches'], branchid)
stmt = (
self.DataBaseManager.select(self.DataBaseManager.model_classes['staff_branches'])
.options(
self.DataBaseManager.selectinload(self.DataBaseManager.model_classes['staff_branches'].roles)
.selectinload(self.DataBaseManager.model_classes['staff_roles'].users)
)
.where(
self.DataBaseManager.model_classes['staff_branches'].id == branchid
)
)
branch = (await session.execute(stmt)).scalars().first()
if branch is None:
await ctx.send(embed = disnake.Embed(description = f'Ветви с идентификатором {branchid} не существует', colour = 0xff9900))
return 1
branch.roles.sort(key=lambda role: role.layer)
embed = disnake.Embed(title = f"", description = f"# Иерархия по ветви {branch.purpose}\n", colour = 0xff9900)
for rolecounter, role in enumerate(branch.roles, start=1):
embed.description += f"## {rolecounter}) <@&{role.id}>"
if devmod:
embed.description += f" layer:({role.layer})"
embed.description += "\n"
for membercounter, user in enumerate(role.users, start=1):
embed.description += f"### - <@{user.user_id}>"
if devmod:
embed.description += f" update_time:(<t:{int(user.update_time)}:R>)"
embed.description += "\n"
await ctx.send(embed = embed)