984 lines
42 KiB
Python
984 lines
42 KiB
Python
import os
|
||
import sqlite3
|
||
import logging
|
||
import asyncio
|
||
from datetime import datetime, timedelta
|
||
try:
|
||
from zoneinfo import ZoneInfo
|
||
except ImportError:
|
||
from backports.zoneinfo import ZoneInfo
|
||
|
||
import disnake
|
||
from disnake.ext import commands, tasks
|
||
from utils.premium import check_premium_tier
|
||
|
||
kuby_logger = logging.getLogger("KubyBot")
|
||
PARIS_TZ = ZoneInfo("Europe/Paris")
|
||
|
||
class ReportsDB:
|
||
def __init__(self, db_path):
|
||
self.db_path = db_path
|
||
self._init_db()
|
||
|
||
def _init_db(self):
|
||
conn = sqlite3.connect(self.db_path)
|
||
cursor = conn.cursor()
|
||
|
||
# Table pour les rapports
|
||
cursor.execute('''
|
||
CREATE TABLE IF NOT EXISTS reports (
|
||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||
guild_id INTEGER NOT NULL,
|
||
author_id INTEGER NOT NULL,
|
||
title TEXT NOT NULL,
|
||
subject TEXT NOT NULL,
|
||
content TEXT NOT NULL,
|
||
status TEXT NOT NULL DEFAULT 'En attente',
|
||
created_at TEXT NOT NULL,
|
||
last_edited_at TEXT,
|
||
channel_id INTEGER NOT NULL,
|
||
role_id_auteur INTEGER
|
||
)
|
||
''')
|
||
|
||
# Table pour la configuration du module
|
||
cursor.execute('''
|
||
CREATE TABLE IF NOT EXISTS reports_config (
|
||
guild_id INTEGER PRIMARY KEY,
|
||
viewer_role_id INTEGER
|
||
)
|
||
''')
|
||
conn.commit()
|
||
conn.close()
|
||
|
||
def get_config(self, guild_id):
|
||
conn = sqlite3.connect(self.db_path)
|
||
cursor = conn.cursor()
|
||
cursor.execute("SELECT viewer_role_id FROM reports_config WHERE guild_id = ?", (guild_id,))
|
||
row = cursor.fetchone()
|
||
conn.close()
|
||
return row[0] if row else None
|
||
|
||
def set_config(self, guild_id, viewer_role_id):
|
||
conn = sqlite3.connect(self.db_path)
|
||
cursor = conn.cursor()
|
||
cursor.execute('''
|
||
INSERT INTO reports_config (guild_id, viewer_role_id)
|
||
VALUES (?, ?)
|
||
ON CONFLICT(guild_id) DO UPDATE SET viewer_role_id = excluded.viewer_role_id
|
||
''', (guild_id, viewer_role_id))
|
||
conn.commit()
|
||
conn.close()
|
||
|
||
def add_report(self, guild_id, author_id, title, subject, content, channel_id, role_id_auteur):
|
||
conn = sqlite3.connect(self.db_path)
|
||
cursor = conn.cursor()
|
||
created_at = datetime.now(PARIS_TZ).isoformat()
|
||
cursor.execute('''
|
||
INSERT INTO reports (guild_id, author_id, title, subject, content, status, created_at, channel_id, role_id_auteur)
|
||
VALUES (?, ?, ?, ?, ?, 'En attente', ?, ?, ?)
|
||
''', (guild_id, author_id, title, subject, content, created_at, channel_id, role_id_auteur))
|
||
report_id = cursor.lastrowid
|
||
conn.commit()
|
||
conn.close()
|
||
return report_id
|
||
|
||
def get_report(self, report_id):
|
||
conn = sqlite3.connect(self.db_path)
|
||
conn.row_factory = sqlite3.Row
|
||
cursor = conn.cursor()
|
||
cursor.execute("SELECT * FROM reports WHERE id = ?", (report_id,))
|
||
row = cursor.fetchone()
|
||
conn.close()
|
||
return dict(row) if row else None
|
||
|
||
def update_report_status(self, report_id, status):
|
||
conn = sqlite3.connect(self.db_path)
|
||
cursor = conn.cursor()
|
||
last_edited_at = datetime.now(PARIS_TZ).isoformat()
|
||
cursor.execute('''
|
||
UPDATE reports
|
||
SET status = ?, last_edited_at = ?
|
||
WHERE id = ?
|
||
''', (status, last_edited_at, report_id))
|
||
conn.commit()
|
||
conn.close()
|
||
|
||
def update_report_content(self, report_id, title, subject, content):
|
||
conn = sqlite3.connect(self.db_path)
|
||
cursor = conn.cursor()
|
||
last_edited_at = datetime.now(PARIS_TZ).isoformat()
|
||
cursor.execute('''
|
||
UPDATE reports
|
||
SET title = ?, subject = ?, content = ?, last_edited_at = ?
|
||
WHERE id = ?
|
||
''', (title, subject, content, last_edited_at, report_id))
|
||
conn.commit()
|
||
conn.close()
|
||
|
||
def delete_report(self, report_id):
|
||
conn = sqlite3.connect(self.db_path)
|
||
cursor = conn.cursor()
|
||
cursor.execute("DELETE FROM reports WHERE id = ?", (report_id,))
|
||
conn.commit()
|
||
conn.close()
|
||
|
||
def get_reports(self, guild_id, author_id=None, subject=None, status=None, role_id=None):
|
||
conn = sqlite3.connect(self.db_path)
|
||
conn.row_factory = sqlite3.Row
|
||
cursor = conn.cursor()
|
||
|
||
query = "SELECT * FROM reports WHERE guild_id = ?"
|
||
params = [guild_id]
|
||
|
||
if author_id is not None:
|
||
query += " AND author_id = ?"
|
||
params.append(author_id)
|
||
if subject is not None:
|
||
query += " AND subject LIKE ?"
|
||
params.append(f"%{subject}%")
|
||
if status is not None:
|
||
query += " AND status = ?"
|
||
params.append(status)
|
||
if role_id is not None:
|
||
query += " AND role_id_auteur = ?"
|
||
params.append(role_id)
|
||
|
||
query += " ORDER BY id ASC"
|
||
|
||
cursor.execute(query, params)
|
||
rows = cursor.fetchall()
|
||
conn.close()
|
||
return [dict(r) for r in rows]
|
||
|
||
def get_distinct_subjects(self, guild_id):
|
||
conn = sqlite3.connect(self.db_path)
|
||
cursor = conn.cursor()
|
||
cursor.execute("SELECT DISTINCT subject FROM reports WHERE guild_id = ? ORDER BY subject ASC", (guild_id,))
|
||
rows = cursor.fetchall()
|
||
conn.close()
|
||
return [row[0] for row in rows if row[0]]
|
||
|
||
def purge_manual(self, guild_id):
|
||
conn = sqlite3.connect(self.db_path)
|
||
cursor = conn.cursor()
|
||
cutoff = (datetime.now(PARIS_TZ) - timedelta(days=7)).isoformat()
|
||
cursor.execute('''
|
||
DELETE FROM reports
|
||
WHERE guild_id = ? AND status != 'Classé' AND created_at < ?
|
||
''', (guild_id, cutoff))
|
||
deleted_count = cursor.rowcount
|
||
conn.commit()
|
||
conn.close()
|
||
return deleted_count
|
||
|
||
def purge_automatic(self):
|
||
conn = sqlite3.connect(self.db_path)
|
||
cursor = conn.cursor()
|
||
cutoff = (datetime.now(PARIS_TZ) - timedelta(days=90)).isoformat()
|
||
cursor.execute('''
|
||
DELETE FROM reports
|
||
WHERE status != 'Classé' AND created_at < ?
|
||
''', (cutoff,))
|
||
deleted_count = cursor.rowcount
|
||
conn.commit()
|
||
conn.close()
|
||
return deleted_count
|
||
|
||
class ReportsConfigView(disnake.ui.View):
|
||
def __init__(self, cog, guild_id: int):
|
||
super().__init__(timeout=300)
|
||
self.cog = cog
|
||
self.guild_id = guild_id
|
||
|
||
@disnake.ui.role_select(placeholder="Modifier le rôle Lecteur (Viewer)", min_values=1, max_values=1, custom_id="reports_select_viewer_role")
|
||
async def select_viewer_role(self, select: disnake.ui.RoleSelect, interaction: disnake.MessageInteraction):
|
||
if not interaction.author.guild_permissions.administrator:
|
||
return await interaction.response.send_message("❌ Vous devez être administrateur pour configurer ce module.", ephemeral=True)
|
||
|
||
role = select.values[0]
|
||
self.cog.db.set_config(self.guild_id, role.id)
|
||
|
||
embed = interaction.message.embeds[0]
|
||
embed.set_field_at(
|
||
0,
|
||
name="👁️ Rôle Lecteur (Viewer)",
|
||
value=f"{role.mention}\n*(Les membres ayant ce rôle peuvent consulter tous les rapports du serveur)*",
|
||
inline=False
|
||
)
|
||
await interaction.response.edit_message(embed=embed, view=self)
|
||
await interaction.followup.send(f"✅ Rôle Lecteur configuré sur {role.mention}", ephemeral=True)
|
||
|
||
@disnake.ui.button(label="Purge Manuelle", style=disnake.ButtonStyle.red, emoji="🗑️", custom_id="reports_manual_purge_btn")
|
||
async def manual_purge(self, button: disnake.ui.Button, interaction: disnake.MessageInteraction):
|
||
if not interaction.author.guild_permissions.administrator:
|
||
return await interaction.response.send_message("❌ Vous devez être administrateur pour lancer la purge.", ephemeral=True)
|
||
|
||
await interaction.response.defer(ephemeral=True)
|
||
deleted_count = self.cog.db.purge_manual(self.guild_id)
|
||
await interaction.followup.send(f"✅ Purge terminée ! **{deleted_count}** rapports (créés il y a > 7 jours et non-classés) ont été définitivement supprimés.", ephemeral=True)
|
||
|
||
class ReportModal(disnake.ui.Modal):
|
||
def __init__(self, cog):
|
||
self.cog = cog
|
||
components = [
|
||
disnake.ui.TextInput(
|
||
label="Titre du rapport",
|
||
placeholder="Entrez le titre du rapport...",
|
||
custom_id="report_title",
|
||
required=True,
|
||
max_length=100
|
||
),
|
||
disnake.ui.TextInput(
|
||
label="Objet du rapport",
|
||
placeholder="Ex: Bug, Plainte, Suggestion...",
|
||
custom_id="report_subject",
|
||
required=True,
|
||
max_length=100
|
||
),
|
||
disnake.ui.TextInput(
|
||
label="Contenu",
|
||
style=disnake.TextInputStyle.paragraph,
|
||
placeholder="Décrivez en détail...",
|
||
custom_id="report_content",
|
||
required=True,
|
||
max_length=2000
|
||
)
|
||
]
|
||
super().__init__(title="Créer un Rapport", custom_id="report_modal", components=components)
|
||
|
||
async def callback(self, interaction: disnake.ModalInteraction):
|
||
title = interaction.text_values["report_title"].strip()
|
||
subject = interaction.text_values["report_subject"].strip()
|
||
content = interaction.text_values["report_content"].strip()
|
||
|
||
role_id_auteur = interaction.author.top_role.id if interaction.author.roles else None
|
||
|
||
report_id = self.cog.db.add_report(
|
||
guild_id=interaction.guild.id,
|
||
author_id=interaction.author.id,
|
||
title=title,
|
||
subject=subject,
|
||
content=content,
|
||
channel_id=interaction.channel.id,
|
||
role_id_auteur=role_id_auteur
|
||
)
|
||
|
||
await interaction.response.send_message(
|
||
f"✅ Votre rapport a été enregistré avec succès sous l'ID **#{report_id}**.",
|
||
ephemeral=True
|
||
)
|
||
|
||
class EditReportModal(disnake.ui.Modal):
|
||
def __init__(self, cog, report_id, browser_view):
|
||
self.cog = cog
|
||
self.report_id = report_id
|
||
self.browser_view = browser_view
|
||
|
||
report = self.cog.db.get_report(report_id)
|
||
|
||
components = [
|
||
disnake.ui.TextInput(
|
||
label="Modifier le titre",
|
||
value=report['title'],
|
||
custom_id="edit_title",
|
||
required=True,
|
||
max_length=100
|
||
),
|
||
disnake.ui.TextInput(
|
||
label="Modifier l'objet",
|
||
value=report['subject'],
|
||
custom_id="edit_subject",
|
||
required=True,
|
||
max_length=100
|
||
),
|
||
disnake.ui.TextInput(
|
||
label="Modifier le contenu",
|
||
style=disnake.TextInputStyle.paragraph,
|
||
value=report['content'],
|
||
custom_id="edit_content",
|
||
required=True,
|
||
max_length=2000
|
||
)
|
||
]
|
||
super().__init__(title=f"Modifier le Rapport #{report_id}", custom_id=f"edit_modal_{report_id}", components=components)
|
||
|
||
async def callback(self, interaction: disnake.ModalInteraction):
|
||
report = self.cog.db.get_report(self.report_id)
|
||
if not report:
|
||
return await interaction.response.send_message("❌ Ce rapport n'existe plus.", ephemeral=True)
|
||
if report['status'] in ['Traité', 'Classé']:
|
||
return await interaction.response.send_message("❌ Ce rapport a été traité ou classé et ne peut plus être modifié.", ephemeral=True)
|
||
|
||
title = interaction.text_values["edit_title"].strip()
|
||
subject = interaction.text_values["edit_subject"].strip()
|
||
content = interaction.text_values["edit_content"].strip()
|
||
|
||
self.cog.db.update_report_content(self.report_id, title, subject, content)
|
||
|
||
updated_report = self.cog.db.get_report(self.report_id)
|
||
|
||
for idx, r in enumerate(self.browser_view.reports):
|
||
if r['id'] == self.report_id:
|
||
self.browser_view.reports[idx] = updated_report
|
||
break
|
||
|
||
self.browser_view.update_components()
|
||
|
||
await interaction.response.defer(ephemeral=True)
|
||
await interaction.message.edit(embed=self.browser_view.get_embed(), view=self.browser_view)
|
||
await interaction.followup.send("✅ Votre rapport a été modifié avec succès.", ephemeral=True)
|
||
|
||
class ReportsFilterView(disnake.ui.View):
|
||
def __init__(self, cog, interaction):
|
||
super().__init__(timeout=300)
|
||
self.cog = cog
|
||
self.interaction = interaction
|
||
self.viewer_id = interaction.author.id
|
||
self.guild_id = interaction.guild.id
|
||
self.is_admin = interaction.author.guild_permissions.administrator
|
||
|
||
viewer_role_id = self.cog.db.get_config(self.guild_id)
|
||
self.is_viewer = viewer_role_id in [r.id for r in interaction.author.roles] if viewer_role_id else False
|
||
self.has_global_access = self.is_admin or self.is_viewer
|
||
|
||
self.selected_user = None
|
||
self.selected_role = None
|
||
self.selected_status = None
|
||
self.selected_subject = None
|
||
|
||
self.update_components()
|
||
|
||
def update_components(self):
|
||
self.clear_items()
|
||
|
||
# Row 0: Menu Status
|
||
status_options = [
|
||
disnake.SelectOption(label="Tous les statuts", emoji="⚪", value="all", default=(self.selected_status is None)),
|
||
disnake.SelectOption(label="En attente", emoji="🟡", value="En attente", default=(self.selected_status == "En attente")),
|
||
disnake.SelectOption(label="Traité", emoji="🟢", value="Traité", default=(self.selected_status == "Traité")),
|
||
disnake.SelectOption(label="Classé", emoji="🔴", value="Classé", default=(self.selected_status == "Classé"))
|
||
]
|
||
status_select = disnake.ui.StringSelect(
|
||
placeholder="Filtrer par statut...",
|
||
options=status_options,
|
||
custom_id="reports_filter_status",
|
||
row=0
|
||
)
|
||
async def status_callback(inter: disnake.MessageInteraction):
|
||
val = inter.values[0]
|
||
self.selected_status = None if val == "all" else val
|
||
self.update_components()
|
||
await inter.response.edit_message(embed=self.get_filter_embed(), view=self)
|
||
status_select.callback = status_callback
|
||
self.add_item(status_select)
|
||
|
||
# Row 1: Menu Catégorie
|
||
subjects = self.cog.db.get_distinct_subjects(self.guild_id)
|
||
if subjects:
|
||
subject_options = [
|
||
disnake.SelectOption(label="Toutes les catégories", emoji="📁", value="all", default=(self.selected_subject is None))
|
||
]
|
||
for subj in subjects[:24]:
|
||
subject_options.append(
|
||
disnake.SelectOption(label=subj, value=subj, default=(self.selected_subject == subj))
|
||
)
|
||
subject_select = disnake.ui.StringSelect(
|
||
placeholder="Filtrer par catégorie...",
|
||
options=subject_options,
|
||
custom_id="reports_filter_subject",
|
||
row=1
|
||
)
|
||
async def subject_callback(inter: disnake.MessageInteraction):
|
||
val = inter.values[0]
|
||
self.selected_subject = None if val == "all" else val
|
||
self.update_components()
|
||
await inter.response.edit_message(embed=self.get_filter_embed(), view=self)
|
||
subject_select.callback = subject_callback
|
||
self.add_item(subject_select)
|
||
|
||
current_row = 2
|
||
|
||
# Row 2 & 3: Filtres utilisateur / rôle (globaux uniquement)
|
||
if self.has_global_access:
|
||
user_select = disnake.ui.UserSelect(
|
||
placeholder="Filtrer par auteur...",
|
||
min_values=0,
|
||
max_values=1,
|
||
custom_id="reports_filter_user",
|
||
row=current_row
|
||
)
|
||
async def user_callback(inter: disnake.MessageInteraction):
|
||
if inter.values:
|
||
val = inter.values[0]
|
||
if isinstance(val, str):
|
||
self.selected_user = inter.guild.get_member(int(val)) or val
|
||
else:
|
||
self.selected_user = val
|
||
else:
|
||
self.selected_user = None
|
||
self.update_components()
|
||
await inter.response.edit_message(embed=self.get_filter_embed(), view=self)
|
||
user_select.callback = user_callback
|
||
self.add_item(user_select)
|
||
current_row += 1
|
||
|
||
role_select = disnake.ui.RoleSelect(
|
||
placeholder="Filtrer par rôle auteur...",
|
||
min_values=0,
|
||
max_values=1,
|
||
custom_id="reports_filter_role",
|
||
row=current_row
|
||
)
|
||
async def role_callback(inter: disnake.MessageInteraction):
|
||
if inter.values:
|
||
val = inter.values[0]
|
||
if isinstance(val, str):
|
||
self.selected_role = inter.guild.get_role(int(val)) or val
|
||
else:
|
||
self.selected_role = val
|
||
else:
|
||
self.selected_role = None
|
||
self.update_components()
|
||
await inter.response.edit_message(embed=self.get_filter_embed(), view=self)
|
||
role_select.callback = role_callback
|
||
self.add_item(role_select)
|
||
current_row += 1
|
||
|
||
# Row 4: Boutons Recherche / Reset
|
||
search_btn = disnake.ui.Button(
|
||
label="Rechercher",
|
||
style=disnake.ButtonStyle.green,
|
||
emoji="🔍",
|
||
custom_id="reports_filter_search",
|
||
row=current_row
|
||
)
|
||
async def search_callback(inter: disnake.MessageInteraction):
|
||
author_filter = None
|
||
if not self.has_global_access:
|
||
author_filter = self.viewer_id
|
||
elif self.selected_user:
|
||
author_filter = self.selected_user.id if hasattr(self.selected_user, "id") else int(self.selected_user)
|
||
|
||
role_filter_id = None
|
||
if self.selected_role:
|
||
role_filter_id = self.selected_role.id if hasattr(self.selected_role, "id") else int(self.selected_role)
|
||
|
||
reports = self.cog.db.get_reports(
|
||
guild_id=self.guild_id,
|
||
author_id=author_filter,
|
||
subject=self.selected_subject,
|
||
status=self.selected_status,
|
||
role_id=role_filter_id
|
||
)
|
||
|
||
if not reports:
|
||
await inter.response.send_message("❌ Aucun rapport ne correspond à votre recherche.", ephemeral=True)
|
||
return
|
||
|
||
browser = ReportsBrowserView(self.cog, self.interaction, reports, filter_view=self)
|
||
await inter.response.edit_message(embed=browser.get_embed(), view=browser)
|
||
|
||
search_btn.callback = search_callback
|
||
self.add_item(search_btn)
|
||
|
||
reset_btn = disnake.ui.Button(
|
||
label="Réinitialiser",
|
||
style=disnake.ButtonStyle.red,
|
||
emoji="❌",
|
||
custom_id="reports_filter_reset",
|
||
row=current_row
|
||
)
|
||
async def reset_callback(inter: disnake.MessageInteraction):
|
||
self.selected_user = None
|
||
self.selected_role = None
|
||
self.selected_status = None
|
||
self.selected_subject = None
|
||
self.update_components()
|
||
await inter.response.edit_message(embed=self.get_filter_embed(), view=self)
|
||
reset_btn.callback = reset_callback
|
||
self.add_item(reset_btn)
|
||
|
||
def get_filter_embed(self) -> disnake.Embed:
|
||
"""Génère l'embed résumant les filtres actifs."""
|
||
author = self.interaction.author
|
||
lines = []
|
||
lines.append(f"🚦 **Statut** : {self.selected_status or 'Tous'}")
|
||
if self.has_global_access:
|
||
if self.selected_user:
|
||
mention = self.selected_user.mention if hasattr(self.selected_user, 'mention') else f'<@{self.selected_user}>'
|
||
lines.append(f"👤 **Auteur** : {mention}")
|
||
else:
|
||
lines.append("👤 **Auteur** : Tous")
|
||
if self.selected_role:
|
||
mention = self.selected_role.mention if hasattr(self.selected_role, 'mention') else f'<@&{self.selected_role}>'
|
||
lines.append(f"🛡️ **Rôle Auteur** : {mention}")
|
||
else:
|
||
lines.append("🛡️ **Rôle Auteur** : Tous")
|
||
else:
|
||
lines.append(f"👤 **Auteur** : {author.mention} *(accès limité à vos rapports)*")
|
||
lines.append(f"📁 **Objet / Catégorie** : {self.selected_subject or 'Tous'}")
|
||
embed = disnake.Embed(
|
||
title="🔍 Recherche & Filtres de Rapports",
|
||
description="\n".join(lines),
|
||
color=disnake.Color.blurple()
|
||
)
|
||
embed.set_thumbnail(url=author.display_avatar.url)
|
||
return embed
|
||
|
||
def get_components_v2(self):
|
||
"""Kept for backward compatibility — returns view children only."""
|
||
return self.children
|
||
|
||
async def interaction_check(self, interaction: disnake.MessageInteraction) -> bool:
|
||
if interaction.author.id != self.viewer_id:
|
||
await interaction.response.send_message("❌ Vous ne pouvez pas interagir avec ce menu.", ephemeral=True)
|
||
return False
|
||
return True
|
||
|
||
class ReportsBrowserView(disnake.ui.View):
|
||
def __init__(self, cog, interaction, reports, filter_view=None, current_index=0):
|
||
super().__init__(timeout=600)
|
||
self.cog = cog
|
||
self.interaction = interaction
|
||
self.guild_id = interaction.guild.id
|
||
self.viewer_id = interaction.author.id
|
||
self.is_admin = interaction.author.guild_permissions.administrator
|
||
self.reports = reports
|
||
self.filter_view = filter_view
|
||
self.current_index = current_index
|
||
self.page_index = current_index // 25
|
||
self.update_components()
|
||
|
||
def update_components(self):
|
||
self.clear_items()
|
||
|
||
if not self.reports:
|
||
return
|
||
|
||
report = self.reports[self.current_index]
|
||
|
||
# Row 0: StringSelectMenu de selection du rapport
|
||
total_pages = (len(self.reports) + 24) // 25
|
||
start = self.page_index * 25
|
||
end = min(start + 25, len(self.reports))
|
||
|
||
options = []
|
||
for i in range(start, end):
|
||
rep = self.reports[i]
|
||
title = rep['title']
|
||
if len(title) > 60:
|
||
title = title[:57] + "..."
|
||
label = f"#{rep['id']} - {title}"
|
||
description = f"Statut: {rep['status']} | Objet: {rep['subject']}"
|
||
if len(description) > 100:
|
||
description = description[:97] + "..."
|
||
options.append(
|
||
disnake.SelectOption(
|
||
label=label,
|
||
description=description,
|
||
value=str(i),
|
||
default=(i == self.current_index)
|
||
)
|
||
)
|
||
|
||
select_menu = disnake.ui.StringSelect(
|
||
placeholder="Sélectionnez un rapport à lire...",
|
||
options=options,
|
||
custom_id="reports_browser_select",
|
||
row=0
|
||
)
|
||
|
||
async def select_callback(inter: disnake.MessageInteraction):
|
||
self.current_index = int(inter.values[0])
|
||
self.page_index = self.current_index // 25
|
||
self.update_components()
|
||
await inter.response.edit_message(embed=self.get_embed(), view=self)
|
||
|
||
select_menu.callback = select_callback
|
||
self.add_item(select_menu)
|
||
|
||
# Row 1: Boutons de pagination de pages (si > 25 rapports)
|
||
if total_pages > 1:
|
||
prev_btn = disnake.ui.Button(
|
||
label="⬅️ Page précédente",
|
||
style=disnake.ButtonStyle.secondary,
|
||
disabled=(self.page_index == 0),
|
||
custom_id="reports_browser_prev_page",
|
||
row=1
|
||
)
|
||
next_btn = disnake.ui.Button(
|
||
label="➡️ Page suivante",
|
||
style=disnake.ButtonStyle.secondary,
|
||
disabled=(self.page_index >= total_pages - 1),
|
||
custom_id="reports_browser_next_page",
|
||
row=1
|
||
)
|
||
|
||
async def prev_callback(inter: disnake.MessageInteraction):
|
||
self.page_index -= 1
|
||
self.current_index = self.page_index * 25
|
||
self.update_components()
|
||
await inter.response.edit_message(embed=self.get_embed(), view=self)
|
||
|
||
async def next_callback(inter: disnake.MessageInteraction):
|
||
self.page_index += 1
|
||
self.current_index = self.page_index * 25
|
||
self.update_components()
|
||
await inter.response.edit_message(embed=self.get_embed(), view=self)
|
||
|
||
prev_btn.callback = prev_callback
|
||
next_btn.callback = next_callback
|
||
self.add_item(prev_btn)
|
||
self.add_item(next_btn)
|
||
|
||
# Row 2: Boutons d'Action (Modifier, Supprimer, Retour)
|
||
is_author = (self.viewer_id == report['author_id'])
|
||
is_blocked = report['status'] in ['Traité', 'Classé']
|
||
|
||
edit_disabled = not is_author or is_blocked
|
||
delete_disabled = not (is_author or self.is_admin) or is_blocked
|
||
|
||
edit_btn = disnake.ui.Button(
|
||
label="Modifier",
|
||
style=disnake.ButtonStyle.primary,
|
||
emoji="✏️",
|
||
disabled=edit_disabled,
|
||
custom_id="reports_browser_edit",
|
||
row=2
|
||
)
|
||
delete_btn = disnake.ui.Button(
|
||
label="Supprimer",
|
||
style=disnake.ButtonStyle.danger,
|
||
emoji="🗑️",
|
||
disabled=delete_disabled,
|
||
custom_id="reports_browser_delete",
|
||
row=2
|
||
)
|
||
back_btn = disnake.ui.Button(
|
||
label="Retour aux filtres",
|
||
style=disnake.ButtonStyle.secondary,
|
||
emoji="⬅️",
|
||
custom_id="reports_browser_back",
|
||
row=2
|
||
)
|
||
|
||
async def edit_callback(inter: disnake.MessageInteraction):
|
||
report_fresh = self.cog.db.get_report(report['id'])
|
||
if not report_fresh:
|
||
return await inter.response.send_message("❌ Ce rapport n'existe plus.", ephemeral=True)
|
||
if report_fresh['status'] in ['Traité', 'Classé']:
|
||
return await inter.response.send_message("❌ Ce rapport a été traité ou classé et ne peut plus être modifié.", ephemeral=True)
|
||
if inter.author.id != report_fresh['author_id']:
|
||
return await inter.response.send_message("❌ Seul l'auteur du rapport peut le modifier.", ephemeral=True)
|
||
|
||
modal = EditReportModal(self.cog, report_fresh['id'], self)
|
||
await inter.response.send_modal(modal)
|
||
|
||
async def delete_callback(inter: disnake.MessageInteraction):
|
||
report_fresh = self.cog.db.get_report(report['id'])
|
||
if not report_fresh:
|
||
return await inter.response.send_message("❌ Ce rapport n'existe plus.", ephemeral=True)
|
||
if report_fresh['status'] in ['Traité', 'Classé']:
|
||
return await inter.response.send_message("❌ Ce rapport a été traité ou classé et ne peut pas être supprimé.", ephemeral=True)
|
||
is_auth = (inter.author.id == report_fresh['author_id'])
|
||
if not (is_auth or inter.author.guild_permissions.administrator):
|
||
return await inter.response.send_message("❌ Vous n'avez pas la permission de supprimer ce rapport.", ephemeral=True)
|
||
|
||
self.cog.db.delete_report(report['id'])
|
||
del self.reports[self.current_index]
|
||
|
||
if not self.reports:
|
||
if self.filter_view:
|
||
self.filter_view.update_components()
|
||
await inter.response.edit_message(
|
||
embed=self.filter_view.get_filter_embed(), view=self.filter_view
|
||
)
|
||
else:
|
||
await inter.response.edit_message(
|
||
content="✅ Le rapport a été supprimé. Plus aucun rapport dans cette recherche.",
|
||
embed=None, view=None
|
||
)
|
||
return
|
||
|
||
if self.current_index >= len(self.reports):
|
||
self.current_index = len(self.reports) - 1
|
||
self.page_index = self.current_index // 25
|
||
|
||
self.update_components()
|
||
await inter.response.edit_message(embed=self.get_embed(), view=self)
|
||
await inter.followup.send("✅ Rapport supprimé avec succès.", ephemeral=True)
|
||
|
||
async def back_callback(inter: disnake.MessageInteraction):
|
||
if self.filter_view:
|
||
self.filter_view.update_components()
|
||
await inter.response.edit_message(
|
||
embed=self.filter_view.get_filter_embed(), view=self.filter_view
|
||
)
|
||
else:
|
||
new_filter_view = ReportsFilterView(self.cog, self.interaction)
|
||
await inter.response.edit_message(
|
||
embed=new_filter_view.get_filter_embed(), view=new_filter_view
|
||
)
|
||
|
||
edit_btn.callback = edit_callback
|
||
delete_btn.callback = delete_callback
|
||
back_btn.callback = back_callback
|
||
self.add_item(edit_btn)
|
||
self.add_item(delete_btn)
|
||
self.add_item(back_btn)
|
||
|
||
# Row 3: Menu Déroulant "Changer l'état" (Admin uniquement)
|
||
if self.is_admin:
|
||
status_options = [
|
||
disnake.SelectOption(label="En attente", emoji="🟡", value="En attente"),
|
||
disnake.SelectOption(label="Traité", emoji="🟢", value="Traité"),
|
||
disnake.SelectOption(label="Classé", emoji="🔴", value="Classé")
|
||
]
|
||
status_menu = disnake.ui.StringSelect(
|
||
placeholder="Changer le statut...",
|
||
options=status_options,
|
||
custom_id="reports_browser_status",
|
||
row=3
|
||
)
|
||
|
||
async def status_callback(inter: disnake.MessageInteraction):
|
||
if not inter.author.guild_permissions.administrator:
|
||
return await inter.response.send_message("❌ Seuls les administrateurs peuvent modifier le statut.", ephemeral=True)
|
||
|
||
old_status = report['status']
|
||
new_status = inter.values[0]
|
||
|
||
if old_status == new_status:
|
||
return await inter.response.send_message(f"ℹ️ Le rapport est déjà en statut **{new_status}**.", ephemeral=True)
|
||
|
||
self.cog.db.update_report_status(report['id'], new_status)
|
||
updated_rep = self.cog.db.get_report(report['id'])
|
||
self.reports[self.current_index] = updated_rep
|
||
|
||
self.update_components()
|
||
await inter.response.edit_message(embed=self.get_embed(), view=self)
|
||
await inter.followup.send(
|
||
f"✅ Statut du rapport **#{report['id']}** mis à jour : **{old_status}** → **{new_status}**.",
|
||
ephemeral=True
|
||
)
|
||
|
||
# === Notification DM à l'auteur ===
|
||
status_colors = {
|
||
"En attente": disnake.Color.yellow(),
|
||
"Traité": disnake.Color.green(),
|
||
"Classé": disnake.Color.greyple(),
|
||
}
|
||
status_emojis = {"En attente": "🟡", "Traité": "🟢", "Classé": "🔴"}
|
||
dm_sent = False
|
||
try:
|
||
author_member = inter.guild.get_member(report['author_id'])
|
||
if not author_member:
|
||
author_member = await inter.guild.fetch_member(report['author_id'])
|
||
|
||
if author_member:
|
||
dm_embed = disnake.Embed(
|
||
title="📋 Mise à jour de votre rapport",
|
||
description=(
|
||
f"Le statut de votre rapport **#{report['id']} — {report['title']}** "
|
||
f"vient d'être modifié."
|
||
),
|
||
color=status_colors.get(new_status, disnake.Color.blurple()),
|
||
timestamp=datetime.now(PARIS_TZ)
|
||
)
|
||
dm_embed.add_field(
|
||
name="Ancien statut",
|
||
value=f"{status_emojis.get(old_status, '⚪')} {old_status}",
|
||
inline=True
|
||
)
|
||
dm_embed.add_field(
|
||
name="Nouveau statut",
|
||
value=f"{status_emojis.get(new_status, '⚪')} {new_status}",
|
||
inline=True
|
||
)
|
||
dm_embed.add_field(name="Modifié par", value=inter.author.mention, inline=False)
|
||
dm_embed.add_field(name="Serveur", value=inter.guild.name, inline=False)
|
||
dm_embed.set_footer(text=f"Rapport #{report['id']} • {inter.guild.name}")
|
||
if inter.guild.icon:
|
||
dm_embed.set_thumbnail(url=inter.guild.icon.url)
|
||
try:
|
||
await author_member.send(embed=dm_embed)
|
||
dm_sent = True
|
||
except disnake.Forbidden:
|
||
kuby_logger.info(
|
||
f"[Rapports] DM impossible pour {author_member} (DMs fermés) — rapport #{report['id']}"
|
||
)
|
||
except Exception as e:
|
||
kuby_logger.error(f"[Rapports] Erreur DM notification: {e}", exc_info=True)
|
||
except disnake.NotFound:
|
||
pass
|
||
except Exception as e:
|
||
kuby_logger.error(f"[Rapports] Erreur récupération membre pour DM: {e}", exc_info=True)
|
||
|
||
dm_note = " • 📬 Auteur notifié par DM." if dm_sent else " • ⚠️ DM non envoyé (DMs fermés ou membre introuvable)."
|
||
await inter.followup.send(
|
||
f"ℹ️{dm_note}",
|
||
ephemeral=True
|
||
)
|
||
|
||
status_menu.callback = status_callback
|
||
self.add_item(status_menu)
|
||
|
||
def get_embed(self):
|
||
if not self.reports:
|
||
return disnake.Embed(
|
||
title="Aucun rapport disponible",
|
||
description="Il n'y a aucun rapport correspondant aux critères.",
|
||
color=disnake.Color.red()
|
||
)
|
||
|
||
report = self.reports[self.current_index]
|
||
|
||
status_colors = {
|
||
"En attente": 0xF1C40F,
|
||
"Traité": 0x2ECC71,
|
||
"Classé": 0x95A5A6
|
||
}
|
||
color = status_colors.get(report['status'], 0x3498DB)
|
||
|
||
status_emojis = {
|
||
"En attente": "🟡 En attente",
|
||
"Traité": "🟢 Traité",
|
||
"Classé": "🔴 Classé"
|
||
}
|
||
status_display = status_emojis.get(report['status'], report['status'])
|
||
|
||
embed = disnake.Embed(
|
||
title=f"Rapport #{report['id']} : {report['title']}",
|
||
description=report['content'],
|
||
color=color
|
||
)
|
||
embed.add_field(name="📁 Objet / Catégorie", value=report['subject'], inline=True)
|
||
embed.add_field(name="🚦 Statut", value=status_display, inline=True)
|
||
embed.add_field(name="👤 Auteur", value=f"<@{report['author_id']}>", inline=True)
|
||
|
||
try:
|
||
created_dt = datetime.fromisoformat(report['created_at'])
|
||
created_ts = int(created_dt.timestamp())
|
||
embed.add_field(name="📅 Date de création", value=f"<t:{created_ts}:F> (<t:{created_ts}:R>)", inline=False)
|
||
except Exception:
|
||
embed.add_field(name="📅 Date de création", value=report['created_at'], inline=False)
|
||
|
||
if report['last_edited_at']:
|
||
try:
|
||
edited_dt = datetime.fromisoformat(report['last_edited_at'])
|
||
edited_str = edited_dt.strftime("%d/%m/%Y à %H:%M")
|
||
embed.set_footer(text=f"Dernière action le {edited_str}")
|
||
except Exception:
|
||
embed.set_footer(text=f"Dernière action le {report['last_edited_at']}")
|
||
else:
|
||
embed.set_footer(text="Rapports Hybrides")
|
||
|
||
return embed
|
||
|
||
async def interaction_check(self, interaction: disnake.MessageInteraction) -> bool:
|
||
if interaction.author.id != self.viewer_id:
|
||
await interaction.response.send_message("❌ Vous ne pouvez pas interagir avec ce menu.", ephemeral=True)
|
||
return False
|
||
return True
|
||
|
||
class Rapports(commands.Cog):
|
||
def __init__(self, bot):
|
||
self.bot = bot
|
||
self.base_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
|
||
self.db_path = os.path.join(self.base_dir, "config.db")
|
||
self.db = ReportsDB(self.db_path)
|
||
self.retention_loop.start()
|
||
|
||
def cog_unload(self):
|
||
self.retention_loop.cancel()
|
||
|
||
@tasks.loop(hours=24)
|
||
async def retention_loop(self):
|
||
try:
|
||
deleted_count = self.db.purge_automatic()
|
||
if deleted_count > 0:
|
||
kuby_logger.info(f"🧹 [Rétention] Nettoyage automatique effectué : {deleted_count} rapports de plus de 90 jours (non classés) supprimés.")
|
||
except Exception as e:
|
||
kuby_logger.error(f"❌ [Rétention] Erreur lors du nettoyage automatique: {e}", exc_info=True)
|
||
|
||
@retention_loop.before_loop
|
||
async def before_retention_loop(self):
|
||
await self.bot.wait_until_ready()
|
||
|
||
@commands.slash_command(name="config-system", description="Configuration du module de rapports (Admin uniquement)")
|
||
@check_premium_tier()
|
||
@commands.has_permissions(administrator=True)
|
||
async def config_system(self, interaction: disnake.ApplicationCommandInteraction, role_viewer: disnake.Role = None):
|
||
guild_id = interaction.guild.id
|
||
|
||
if role_viewer:
|
||
self.db.set_config(guild_id, role_viewer.id)
|
||
viewer_text = f"{role_viewer.mention}"
|
||
else:
|
||
viewer_role_id = self.db.get_config(guild_id)
|
||
viewer_text = f"<@&{viewer_role_id}>" if viewer_role_id else "Aucun rôle configuré"
|
||
|
||
embed = disnake.Embed(
|
||
title="⚙️ Configuration du Système de Rapports",
|
||
description="Gérez les autorisations de consultation globale et effectuez la maintenance.",
|
||
color=disnake.Color.blue()
|
||
)
|
||
embed.add_field(
|
||
name="👁️ Rôle Lecteur (Viewer)",
|
||
value=f"{viewer_text}\n*(Les membres ayant ce rôle peuvent consulter tous les rapports du serveur)*",
|
||
inline=False
|
||
)
|
||
embed.add_field(
|
||
name="🧹 Maintenance & Rétention",
|
||
value="Les rapports vieux de plus de **90 jours** sont automatiquement nettoyés chaque jour, sauf s'ils sont **Classés**.\n\nVous pouvez également lancer une purge manuelle pour supprimer les rapports de plus de **7 jours** non classés.",
|
||
inline=False
|
||
)
|
||
embed.set_footer(text="Système de Rapports Hybride")
|
||
|
||
view = ReportsConfigView(self, guild_id)
|
||
await interaction.response.send_message(embed=embed, view=view, ephemeral=True)
|
||
|
||
@commands.slash_command(name="rapport", description="Ouvrir le formulaire de saisie de rapport")
|
||
@check_premium_tier()
|
||
async def rapport(self, interaction: disnake.ApplicationCommandInteraction):
|
||
await interaction.response.send_modal(ReportModal(self))
|
||
|
||
@commands.slash_command(name="consulter_rapport", description="Consulter les rapports du serveur via une interface interactive")
|
||
@check_premium_tier()
|
||
async def consulter_rapport(
|
||
self,
|
||
interaction: disnake.ApplicationCommandInteraction,
|
||
utilisateur: disnake.Member = None,
|
||
categorie: str = None,
|
||
statut: str = commands.Param(None, choices=["En attente", "Traité", "Classé"]),
|
||
role: disnake.Role = None
|
||
):
|
||
filter_view = ReportsFilterView(self, interaction)
|
||
if utilisateur:
|
||
filter_view.selected_user = utilisateur
|
||
if categorie:
|
||
filter_view.selected_subject = categorie
|
||
if statut:
|
||
filter_view.selected_status = statut
|
||
if role:
|
||
filter_view.selected_role = role
|
||
|
||
filter_view.update_components()
|
||
await interaction.response.send_message(
|
||
embed=disnake.Embed(
|
||
title="🔍 Recherche & Filtres de Rapports",
|
||
description=(
|
||
f"🚦 **Statut** : {filter_view.selected_status or 'Tous'}\n"
|
||
f"📁 **Objet / Catégorie** : {filter_view.selected_subject or 'Tous'}\n"
|
||
+ (f"👤 **Auteur** : {filter_view.selected_user.mention if hasattr(filter_view.selected_user, 'mention') else 'Tous'}\n" if filter_view.has_global_access else f"👤 **Auteur** : {interaction.author.mention} *(accès limité à vos rapports)*\n")
|
||
+ (f"🛡️ **Rôle Auteur** : {filter_view.selected_role.mention if hasattr(filter_view.selected_role, 'mention') else 'Tous'}" if filter_view.has_global_access else "")
|
||
),
|
||
color=disnake.Color.blurple()
|
||
),
|
||
view=filter_view,
|
||
ephemeral=True
|
||
)
|
||
|
||
def setup(bot):
|
||
bot.add_cog(Rapports(bot))
|