285 lines
11 KiB
Python
Executable file
285 lines
11 KiB
Python
Executable file
import discord
|
||
from discord.ext import commands
|
||
from discord.ui import View, Button
|
||
import json
|
||
import os
|
||
from datetime import datetime
|
||
from typing import List, Dict, Optional
|
||
|
||
class WhitelistMonitor(commands.Cog):
|
||
"""Monitors whitelist members for role changes and server leave events."""
|
||
|
||
def __init__(self, bot):
|
||
self.bot = bot
|
||
self.whitelist_file = "data/whitelist.json"
|
||
self.persistent_views_added = False
|
||
self.big_permissions = [
|
||
discord.Permissions.administrator,
|
||
discord.Permissions.manage_guild,
|
||
discord.Permissions.manage_roles,
|
||
discord.Permissions.manage_channels,
|
||
discord.Permissions.kick_members,
|
||
discord.Permissions.ban_members,
|
||
discord.Permissions.manage_messages,
|
||
discord.Permissions.moderate_members,
|
||
discord.Permissions.manage_nicknames,
|
||
discord.Permissions.manage_emojis,
|
||
discord.Permissions.manage_webhooks,
|
||
discord.Permissions.view_audit_log
|
||
]
|
||
|
||
def load_whitelist(self) -> List[str]:
|
||
"""Load whitelist from JSON file."""
|
||
if not os.path.exists(self.whitelist_file):
|
||
return []
|
||
try:
|
||
with open(self.whitelist_file, "r", encoding="utf-8") as f:
|
||
return json.load(f)
|
||
except (json.JSONDecodeError, FileNotFoundError):
|
||
return []
|
||
|
||
def save_whitelist(self, whitelist: List[str]):
|
||
"""Save whitelist to JSON file."""
|
||
with open(self.whitelist_file, "w", encoding="utf-8") as f:
|
||
json.dump(whitelist, f, ensure_ascii=False, indent=4)
|
||
|
||
def is_whitelisted(self, user_id: int) -> bool:
|
||
"""Check if user is whitelisted."""
|
||
whitelist = self.load_whitelist()
|
||
return str(user_id) in whitelist
|
||
|
||
def remove_from_whitelist(self, user_id: int) -> bool:
|
||
"""Remove user from whitelist."""
|
||
whitelist = self.load_whitelist()
|
||
user_str = str(user_id)
|
||
if user_str in whitelist:
|
||
whitelist.remove(user_str)
|
||
self.save_whitelist(whitelist)
|
||
return True
|
||
return False
|
||
|
||
def has_big_permissions(self, role: discord.Role) -> bool:
|
||
"""Check if role has significant permissions."""
|
||
permissions = role.permissions
|
||
for perm in self.big_permissions:
|
||
if permissions.administrator or getattr(permissions, perm.name, False):
|
||
return True
|
||
return False
|
||
|
||
async def send_whitelist_notification(self, member: discord.Member, removed_roles: List[discord.Role]):
|
||
"""Send DM notification to user about whitelist member losing roles."""
|
||
try:
|
||
# Find guild administrators to notify
|
||
admins = [m for m in member.guild.members if m.guild_permissions.administrator and not m.bot]
|
||
if not admins:
|
||
return
|
||
|
||
# Create embed
|
||
embed = discord.Embed(
|
||
title="⚠️ Whitelist Alert",
|
||
description=f"Un membre whitelisté a perdu des rôles importants dans **{member.guild.name}**.",
|
||
color=discord.Color.orange(),
|
||
timestamp=datetime.now()
|
||
)
|
||
|
||
embed.add_field(
|
||
name="👤 Membre concerné",
|
||
value=f"{member.mention} ({member.display_name})",
|
||
inline=False
|
||
)
|
||
|
||
if removed_roles:
|
||
roles_text = "\n".join([f"• {role.name}" for role in removed_roles])
|
||
embed.add_field(
|
||
name="🗑️ Rôles retirés",
|
||
value=roles_text,
|
||
inline=False
|
||
)
|
||
|
||
embed.add_field(
|
||
name="📋 Statut whitelist",
|
||
value="✅ Toujours whitelisté",
|
||
inline=True
|
||
)
|
||
|
||
# Create view with removal button
|
||
view = WhitelistRemovalView(member.id, member.guild.id)
|
||
|
||
# Send to all admins
|
||
for admin in admins:
|
||
try:
|
||
await admin.send(embed=embed, view=view)
|
||
except discord.Forbidden:
|
||
continue # User has DMs disabled
|
||
|
||
except Exception as e:
|
||
print(f"Error sending whitelist notification: {e}")
|
||
|
||
async def cog_load(self):
|
||
"""Register persistent views when cog is loaded"""
|
||
await self._register_persistent_views()
|
||
|
||
async def _register_persistent_views(self):
|
||
"""Register all persistent views for guilds with whitelist alerts"""
|
||
if self.persistent_views_added:
|
||
return
|
||
|
||
try:
|
||
import json
|
||
security_file = "data/security_settings.json"
|
||
if os.path.exists(security_file):
|
||
with open(security_file, "r", encoding="utf-8") as f:
|
||
all_settings = json.load(f)
|
||
|
||
# For each guild with whitelist monitoring, register a default view
|
||
# We'll use a generic view that gets recreated when needed
|
||
# The key is that each unique custom_id needs to be registered once
|
||
view = WhitelistRemovalView(0, 0) # Placeholder with dummy IDs
|
||
self.bot.add_view(view)
|
||
print(f"[WhitelistMonitor] Persistent view registered")
|
||
|
||
self.persistent_views_added = True
|
||
except Exception as e:
|
||
print(f"[WhitelistMonitor] Error registering views: {e}")
|
||
|
||
@commands.Cog.listener()
|
||
async def on_member_update(self, before: discord.Member, after: discord.Member):
|
||
"""Monitor role changes for whitelist members."""
|
||
if before.roles == after.roles:
|
||
return
|
||
|
||
if not self.is_whitelisted(after.id):
|
||
return
|
||
|
||
# Find removed roles
|
||
removed_roles = [role for role in before.roles if role not in after.roles]
|
||
|
||
# Check if any removed roles had big permissions
|
||
important_removed = [role for role in removed_roles if self.has_big_permissions(role)]
|
||
|
||
if important_removed:
|
||
await self.send_whitelist_notification(after, important_removed)
|
||
|
||
@commands.Cog.listener()
|
||
async def on_member_remove(self, member: discord.Member):
|
||
"""Auto-remove from whitelist when member leaves server."""
|
||
if self.is_whitelisted(member.id):
|
||
removed = self.remove_from_whitelist(member.id)
|
||
if removed:
|
||
# Log the removal
|
||
try:
|
||
log_channel_id = self.get_log_channel(member.guild.id)
|
||
if log_channel_id:
|
||
log_channel = member.guild.get_channel(log_channel_id)
|
||
if log_channel:
|
||
embed = discord.Embed(
|
||
title="🗑️ Auto-Whitelist Removal",
|
||
description=f"{member.mention} a été retiré automatiquement de la whitelist après avoir quitté le serveur.",
|
||
color=discord.Color.red(),
|
||
timestamp=datetime.now()
|
||
)
|
||
await log_channel.send(embed=embed)
|
||
except Exception as e:
|
||
print(f"Error logging whitelist removal: {e}")
|
||
|
||
def get_log_channel(self, guild_id: int) -> Optional[int]:
|
||
"""Get log channel ID from security settings."""
|
||
try:
|
||
security_file = "data/security_settings.json"
|
||
if os.path.exists(security_file):
|
||
with open(security_file, "r") as f:
|
||
settings = json.load(f)
|
||
return settings.get(str(guild_id), {}).get("log_channel_id")
|
||
except:
|
||
pass
|
||
return None
|
||
|
||
class WhitelistRemovalView(View):
|
||
"""View with button to remove user from whitelist."""
|
||
|
||
def __init__(self, user_id: int, guild_id: int):
|
||
super().__init__(timeout=None) # Persistent view
|
||
self.user_id = user_id
|
||
self.guild_id = guild_id
|
||
|
||
@discord.ui.button(
|
||
label="Retirer de la whitelist",
|
||
style=discord.ButtonStyle.red,
|
||
emoji="🗑️",
|
||
custom_id="whitelist_remove_button"
|
||
)
|
||
async def remove_whitelist(
|
||
self,
|
||
interaction: discord.Interaction,
|
||
button: Button
|
||
):
|
||
"""Remove user from whitelist when button is clicked."""
|
||
try:
|
||
# Get the cog instance
|
||
cog = self.bot.get_cog("WhitelistMonitor")
|
||
if not cog:
|
||
await interaction.response.send_message(
|
||
"❌ Erreur: Système de whitelist non disponible.",
|
||
ephemeral=True
|
||
)
|
||
return
|
||
|
||
# Remove from whitelist
|
||
removed = cog.remove_from_whitelist(self.user_id)
|
||
|
||
if removed:
|
||
# Get user info
|
||
try:
|
||
user = await self.bot.fetch_user(self.user_id)
|
||
user_mention = user.mention
|
||
except:
|
||
user_mention = f"<@{self.user_id}>"
|
||
|
||
# Update button
|
||
button.disabled = True
|
||
button.label = "✅ Retiré"
|
||
button.style = discord.ButtonStyle.green
|
||
|
||
await interaction.response.edit_message(view=self)
|
||
|
||
# Send confirmation
|
||
embed = discord.Embed(
|
||
title="✅ Retrait effectué",
|
||
description=f"{user_mention} a été retiré de la whitelist.",
|
||
color=discord.Color.green()
|
||
)
|
||
await interaction.followup.send(embed=embed, ephemeral=True)
|
||
|
||
# Log the removal
|
||
try:
|
||
guild = self.bot.get_guild(self.guild_id)
|
||
if guild:
|
||
log_channel_id = cog.get_log_channel(self.guild_id)
|
||
if log_channel_id:
|
||
log_channel = guild.get_channel(log_channel_id)
|
||
if log_channel:
|
||
embed = discord.Embed(
|
||
title="🗑️ Whitelist Manual Removal",
|
||
description=f"{user_mention} a été retiré manuellement de la whitelist.",
|
||
color=discord.Color.green(),
|
||
timestamp=datetime.now()
|
||
)
|
||
embed.set_footer(text=f"Retiré par {interaction.user.display_name}")
|
||
await log_channel.send(embed=embed)
|
||
except Exception as e:
|
||
print(f"Error logging manual removal: {e}")
|
||
|
||
else:
|
||
await interaction.response.send_message(
|
||
"ℹ️ L'utilisateur n'était pas dans la whitelist.",
|
||
ephemeral=True
|
||
)
|
||
|
||
except Exception as e:
|
||
await interaction.response.send_message(
|
||
f"❌ Erreur lors du retrait: {str(e)}",
|
||
ephemeral=True
|
||
)
|
||
|
||
async def setup(bot):
|
||
await bot.add_cog(WhitelistMonitor(bot))
|