import discord from discord import app_commands from discord.ext import commands, tasks import asyncio import logging import os from datetime import datetime import json from dotenv import load_dotenv # Charger les variables d'environnement depuis .env load_dotenv() # Import des modules personnalisés from modules.scraper import VideoScraper from modules.llm_processor import LLMProcessor from modules.database import Database from modules.user_manager import UserManager from modules.contract_generator import ContractGenerator from modules.user_registration import UserRegistrationModal, UserProfileView # Configuration du logging logging.basicConfig( level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', handlers=[ logging.FileHandler('logs/scambot.log'), logging.StreamHandler() ] ) logger = logging.getLogger(__name__) # Configuration du bot intents = discord.Intents.default() intents.message_content = True intents.guilds = True class SCAMBot(commands.Bot): def __init__(self): super().__init__( command_prefix="!", intents=intents, help_command=None ) # Initialisation des modules self.scraper = VideoScraper() self.llm = LLMProcessor() self.db = Database() self.user_manager = UserManager() self.contract_generator = ContractGenerator() # Configuration self.monitoring_interval = 900 # 15 minutes self.admin_users = [] # Liste des IDs d'utilisateurs admin async def setup_hook(self): """Configuration initiale du bot""" logger.info("🚀 Initialisation du SCAMBot...") # Charger les admins depuis un fichier de config try: with open('config/admins.json', 'r') as f: config = json.load(f) self.admin_users = config.get('admin_users', []) self.server_id = config.get('server_id', 0) self.notification_channel_id = config.get('notification_channel_id', 0) except FileNotFoundError: logger.warning("⚠️ Fichier config/admins.json non trouvé") self.admin_users = [] self.server_id = 0 self.notification_channel_id = 0 # Démarrer le monitoring automatique self.monitoring_task.start() logger.info("✅ SCAMBot initialisé avec succès") async def on_ready(self): """Événement déclenché quand le bot est prêt""" logger.info(f"🤖 SCAMBot connecté en tant que {self.user}") logger.info(f"📊 Serviteurs: {len(self.guilds)}") # Synchroniser les commandes slash try: synced = await self.tree.sync() logger.info(f"✅ {len(synced)} commande(s) synchronisée(s)") except Exception as e: logger.error(f"❌ Erreur synchronisation commandes: {e}") @tasks.loop(minutes=15) async def monitoring_task(self): """Tâche de monitoring automatique""" logger.info("🔍 Démarrage du monitoring automatique...") try: # Envoyer une notification de test dans le canal de notification if self.notification_channel_id: channel = self.get_channel(self.notification_channel_id) if channel: embed = discord.Embed( title="🤖 SCAMBot - Monitoring", description="Le bot surveille les créateurs et détecte les nouvelles vidéos.", color=0x00ff00, timestamp=datetime.now() ) embed.add_field(name="📊 Statut", value="✅ Actif", inline=True) embed.add_field(name="⏰ Fréquence", value="Toutes les 15 minutes", inline=True) embed.set_footer(text="SCAMBot - Swiplay") await channel.send(embed=embed) logger.info(f"✅ Notification envoyée dans le canal {self.notification_channel_id}") else: logger.error(f"❌ Canal de notification non trouvé: {self.notification_channel_id}") creators = self.db.list_creators() for creator in creators: creator_id, pseudo, platform, profile_url, discord_channel_id, created_at = creator logger.info(f"👤 Monitoring {pseudo} ({platform})") # Ici, vous pourriez implémenter la logique pour détecter de nouvelles vidéos # Pour l'instant, on simule avec une vidéo de test # TODO: Implémenter la détection de nouvelles vidéos except Exception as e: logger.error(f"❌ Erreur monitoring: {e}") @monitoring_task.before_loop async def before_monitoring(self): """Attendre que le bot soit prêt avant de démarrer le monitoring""" await self.wait_until_ready() async def process_video_url(self, url, channel, force_reprocess=False, user_id=None): """Traite une URL de vidéo et génère le formulaire SCAM""" try: # Vérifier si la vidéo a déjà été traitée if self.db.is_video_processed(url) and not force_reprocess: processed_data = self.db.get_processed_form(url) if processed_data: # Récupérer les pages depuis la base pages_data = {} try: # Si on a des pages stockées, les parser if 'full_form_data' in processed_data: pages_data = self.llm.parse_scam_pages(processed_data['full_form_data']) else: # Ancien format, créer les pages à partir des données existantes pages_data = { 'page1': processed_data['form_data'], 'page2': f"**2 | Les diffusions**\n- **Type de diffusion :** Internet\n- **Nom du site internet :** {processed_data.get('platform', 'À compléter')}\n- **URL :** {url}\n- **Date de mise en ligne :** {processed_data.get('video_published_date', 'À compléter')}\n- **Durée :** {processed_data.get('video_duration', 'À compléter')}", 'page5': "**5 | Thématiques et mots-clés**\n- **Thématiques :** À compléter\n- **Mots-clés :** À compléter" } except Exception as e: logger.error(f"Erreur parsing pages existantes: {e}") pages_data = { 'page1': processed_data['form_data'], 'page2': "Erreur de parsing", 'page5': "Erreur de parsing" } # Ajouter les données utilisateur à la page 6 si disponibles if user_id: user_data = self.user_manager.get_user(user_id) if user_data: # Extraire l'année de production depuis les données stockées annee_production = "2025" # Valeur par défaut if processed_data.get('video_published_date') and processed_data['video_published_date'] != "Non trouvée": try: from datetime import datetime date_obj = datetime.strptime(processed_data['video_published_date'], '%d/%m/%Y') annee_production = str(date_obj.year) except: pass pages_data['page6'] = f"""**6 | Auteurs et producteurs** 📋 **Informations pour le formulaire SCAM :** **Auteur 1 :** • **Prénom et nom :** {user_data['prenom']} {user_data['nom']} • **Fonction :** Auteur - Réalisateur • **Adresse postale :** {user_data['rue']}, {user_data['code_postal']} {user_data['ville']} • **Courriel :** {user_data['email']} • **Tél. mobile :** {user_data['telephone']} • **Part de droits :** 100% ⚠️ **Cocher "Mon œuvre est en autoproduction"** **Producteur 1 :** • **Nom de la société :** AUTOPRODUCTION • **Année de production :** {annee_production} • **Pays de la société de production :** FRANCE""" else: pages_data['page6'] = """**6 | Auteurs et producteurs** ❌ **Aucune donnée utilisateur trouvée** Utilisez `/register` pour enregistrer vos informations personnelles et bénéficier de la génération automatique des contrats PDF.""" else: pages_data['page6'] = """**6 | Auteurs et producteurs** ⚠️ **Informations utilisateur non disponibles** Utilisez `/register` pour enregistrer vos informations personnelles.""" # Envoyer avec navigation await self.send_scam_form_with_navigation( channel, processed_data['game_name'], pages_data, url, video_data=None, user_id=user_id ) return # Scraper la vidéo video_data = self.scraper.scrape_video(url) if not video_data: await channel.send("❌ Impossible de récupérer les données de la vidéo.") return # Générer le formulaire SCAM result = self.llm.process_video(video_data) if result['success']: # Ajouter les données utilisateur à la page 6 si disponibles if user_id: user_data = self.user_manager.get_user(user_id) if user_data: # Extraire l'année de production depuis la date de publication annee_production = "2025" # Valeur par défaut if video_data.get('published_date') and video_data['published_date'] != "Non trouvée": try: from datetime import datetime date_obj = datetime.strptime(video_data['published_date'], '%d/%m/%Y') annee_production = str(date_obj.year) except: pass result['pages']['page6'] = f"""**6 | Auteurs et producteurs** 📋 **Informations pour le formulaire SCAM :** **Auteur 1 :** • **Prénom et nom :** {user_data['prenom']} {user_data['nom']} • **Fonction :** Auteur - Réalisateur • **Adresse postale :** {user_data['rue']}, {user_data['code_postal']} {user_data['ville']} • **Courriel :** {user_data['email']} • **Tél. mobile :** {user_data['telephone']} • **Part de droits :** 100% ⚠️ **Cocher "Mon œuvre est en autoproduction"** **Producteur 1 :** • **Nom de la société :** AUTOPRODUCTION • **Année de production :** {annee_production} • **Pays de la société de production :** FRANCE""" else: result['pages']['page6'] = """**6 | Auteurs et producteurs** ❌ **Aucune donnée utilisateur trouvée** Utilisez `/register` pour enregistrer vos informations personnelles et bénéficier de la génération automatique des contrats PDF.""" else: result['pages']['page6'] = """**6 | Auteurs et producteurs** ⚠️ **Informations utilisateur non disponibles** Utilisez `/register` pour enregistrer vos informations personnelles.""" # Envoyer avec navigation await self.send_scam_form_with_navigation( channel, result['game_name'], result['pages'], url, video_data, user_id=user_id ) # Sauvegarder ou mettre à jour dans la base de données if force_reprocess: self.db.update_processed_video( video_url=url, form_data=result['full_form_data'], game_name=result['game_name'], full_form_data=result['full_form_data'] ) else: # TODO: Récupérer le creator_id approprié self.db.add_processed_video( creator_id=1, # Temporaire video_url=url, video_title=result['game_name'], video_duration=video_data['duration'], video_published_date=video_data.get('published_date', 'Non trouvée'), game_name=result['game_name'], form_data=result['full_form_data'], full_form_data=result['full_form_data'] ) else: await channel.send(f"❌ Erreur lors de la génération: {result['error']}") except Exception as e: logger.error(f"❌ Erreur traitement vidéo: {e}") await channel.send(f"❌ Erreur inattendue: {str(e)}") async def send_scam_form_with_navigation(self, channel, game_name, pages_data, url, video_data, user_id=None): """Envoie le formulaire SCAM avec système de navigation""" try: # Créer la vue pour gérer le PDF view = ScamFormNavigationView(self, game_name, pages_data, url, video_data, user_id) # Générer le PDF d'abord si l'utilisateur est inscrit user_data = self.user_manager.get_user(user_id) if user_id else None if user_data and video_data: logger.info(f"🔄 Génération PDF pour {user_data['prenom']} {user_data['nom']} avant envoi des pages") # Utiliser la fonction get_creator_pseudo du bot pour obtenir le bon pseudonyme creator_pseudo = view.get_creator_pseudo(user_data, video_data.get('platform', 'unknown')) result = self.contract_generator.generate_contract(user_data, video_data, creator_pseudo, url) if result['success']: view.pdf_path = result['pdf_path'] view.pdf_filename = result['filename'] view.pdf_type = "Personnalisé" logger.info(f"✅ PDF prêt: {result['filename']}") else: logger.error(f"❌ Erreur génération PDF: {result['error']}") # Envoyer toutes les pages importantes en séquence pages_to_send = ['page1', 'page2', 'page5', 'page6', 'page7'] for page_key in pages_to_send: embed = view.create_page_embed(page_key) await channel.send(embed=embed) # Petit délai pour éviter le rate limiting await asyncio.sleep(0.5) # Si l'utilisateur est inscrit, envoyer automatiquement le PDF if user_data and hasattr(view, 'pdf_path') and view.pdf_path and os.path.exists(view.pdf_path): try: with open(view.pdf_path, 'rb') as f: pdf_file = discord.File(f, filename=view.pdf_filename) await channel.send( f"📄 **Contrat personnalisé généré pour {user_data['prenom']} {user_data['nom']}**", file=pdf_file ) logger.info(f"✅ PDF {view.pdf_filename} envoyé automatiquement") except Exception as e: logger.error(f"❌ Erreur envoi automatique PDF: {e}") await channel.send(f"❌ Erreur lors de l'envoi du PDF: {e}") logger.info(f"✅ Formulaire SCAM complet envoyé pour {game_name}") except discord.errors.HTTPException as e: logger.error(f"❌ Erreur HTTP Discord: {e}") # Fallback: envoyer sans navigation try: embed = discord.Embed( title=f"📋 Déclaration SCAM pour {game_name}", description=pages_data.get('page1', 'Erreur de génération'), color=0x00ff00, timestamp=datetime.now() ) embed.set_footer(text="SCAMBot - Swiplay | Navigation indisponible") await channel.send(embed=embed) except Exception as fallback_error: logger.error(f"❌ Erreur fallback: {fallback_error}") await channel.send(f"❌ Erreur affichage formulaire pour {game_name}") except Exception as e: logger.error(f"❌ Erreur envoi navigation: {e}") await channel.send(f"❌ Erreur affichage: {str(e)}") # Classe pour la navigation entre les pages du formulaire SCAM class ScamFormNavigationView(discord.ui.View): def __init__(self, bot, game_name, pages_data, url, video_data, user_id=None): super().__init__(timeout=300) # 5 minutes timeout self.bot = bot self.game_name = game_name self.pages_data = pages_data self.url = url self.video_data = video_data self.current_page = 'page1' self.user_id = user_id # Variables pour le PDF généré automatiquement self.pdf_path = None self.pdf_filename = None self.pdf_type = None def get_creator_pseudo(self, user_data, platform): """Récupère le pseudonyme du créateur selon la plateforme""" try: if platform.lower() == 'instagram': # Pour Instagram, utiliser le champ instagram du user_data s'il existe if user_data and 'instagram' in user_data and user_data['instagram']: return user_data['instagram'] else: return "votre_pseudo_instagram" elif platform.lower() in ['youtube', 'tiktok']: return "votre_pseudo_youtube" else: return "votre_pseudo" except Exception as e: logger.warning(f"⚠️ Erreur récupération pseudonyme: {e}") return "votre_pseudo" def create_page_embed(self, page_key): """Crée l'embed pour une page spécifique""" page_titles = { 'page1': "1 | L'œuvre", 'page2': "2 | Les diffusions", 'page5': "5 | Thématiques et mots-clés", 'page6': "6 | Auteurs et producteurs", 'page7': "7 | Validation" } page_colors = { 'page1': 0x00ff00, # Vert 'page2': 0x0099ff, # Bleu 'page5': 0xff9900, # Orange 'page6': 0x9932cc, # Violet 'page7': 0xff0000 # Rouge } embed = discord.Embed( title=f"📋 Déclaration SCAM pour {self.game_name}", description=self.pages_data.get(page_key, "Contenu non disponible"), color=page_colors.get(page_key, 0x00ff00), timestamp=datetime.now() ) embed.add_field(name="📄 Page", value=page_titles.get(page_key, "Page inconnue"), inline=True) embed.add_field(name="🔗 Lien", value=self.url, inline=True) embed.set_footer(text="SCAMBot - Swiplay") return embed @discord.ui.button(label="📄 Page 1", style=discord.ButtonStyle.primary, emoji="1️⃣") async def page1_button(self, interaction: discord.Interaction, button: discord.ui.Button): """Afficher la page 1""" self.current_page = 'page1' embed = self.create_page_embed('page1') await interaction.response.edit_message(embed=embed, view=self) @discord.ui.button(label="📄 Page 2", style=discord.ButtonStyle.primary, emoji="2️⃣") async def page2_button(self, interaction: discord.Interaction, button: discord.ui.Button): """Afficher la page 2""" self.current_page = 'page2' embed = self.create_page_embed('page2') await interaction.response.edit_message(embed=embed, view=self) @discord.ui.button(label="📄 Page 5", style=discord.ButtonStyle.primary, emoji="5️⃣") async def page5_button(self, interaction: discord.Interaction, button: discord.ui.Button): """Afficher la page 5""" self.current_page = 'page5' embed = self.create_page_embed('page5') await interaction.response.edit_message(embed=embed, view=self) @discord.ui.button(label="📄 Page 6", style=discord.ButtonStyle.primary, emoji="6️⃣") async def page6_button(self, interaction: discord.Interaction, button: discord.ui.Button): """Afficher la page 6 avec données utilisateur si disponibles""" self.current_page = 'page6' # Mettre à jour la page 6 avec les données utilisateur si disponibles if self.user_id: user_data = self.bot.user_manager.get_user(self.user_id) if user_data: # Extraire l'année de production depuis la date de publication de la vidéo annee_production = str(datetime.now().year) # Valeur par défaut if self.video_data and self.video_data.get('published_date') and self.video_data['published_date'] != "Non trouvée": try: date_obj = datetime.strptime(self.video_data['published_date'], '%d/%m/%Y') annee_production = str(date_obj.year) except: pass self.pages_data['page6'] = f"""**6 | Auteurs et producteurs** 📋 **Informations pour le formulaire SCAM :** **Auteur 1 :** • **Prénom et nom :** {user_data['prenom']} {user_data['nom']} • **Fonction :** Auteur - Réalisateur • **Adresse postale :** {user_data['rue']}, {user_data['code_postal']} {user_data['ville']} • **Courriel :** {user_data['email']} • **Tél. mobile :** {user_data['telephone']} • **Part de droits :** 100% ⚠️ **Cocher "Mon œuvre est en autoproduction"** **Producteur 1 :** • **Nom de la société :** AUTOPRODUCTION • **Année de production :** {annee_production} • **Pays de la société de production :** FRANCE *Ces informations seront automatiquement utilisées pour la génération des contrats PDF.*""" else: self.pages_data['page6'] = """**6 | Auteurs et producteurs** ❌ **Aucune donnée utilisateur trouvée** Utilisez `/register` pour enregistrer vos informations personnelles et bénéficier de la génération automatique des contrats PDF.""" else: # Garder la page 6 par défaut si pas d'user_id if '**6 | Auteurs et producteurs**' not in self.pages_data.get('page6', ''): self.pages_data['page6'] = """**6 | Auteurs et producteurs** ⚠️ **Informations utilisateur non disponibles** Utilisez `/register` pour enregistrer vos informations personnelles.""" embed = self.create_page_embed('page6') await interaction.response.edit_message(embed=embed, view=self) @discord.ui.button(label="📄 Page 7", style=discord.ButtonStyle.primary, emoji="7️⃣") async def page7_button(self, interaction: discord.Interaction, button: discord.ui.Button): """Afficher la page 7 avec génération automatique du PDF""" self.current_page = 'page7' # Déférer la réponse car la génération PDF peut prendre du temps await interaction.response.defer() try: # Vérifier si l'utilisateur est inscrit pour générer un PDF personnalisé user_data = self.bot.user_manager.get_user(self.user_id) if self.user_id else None if user_data: # Utilisateur inscrit - afficher les informations sans génération automatique logger.info(f"🔍 Page 7 pour utilisateur inscrit: {user_data['prenom']} {user_data['nom']}") latex_available = self.bot.contract_generator.check_latex_installation() if latex_available: pdf_info = f"""**7 | Validation** 📋 **Je souhaite transmettre ma déclaration** ✅ Par voie électronique 📎 **Documents à joindre** ✅ Contrat PDF (génération automatique disponible) 👤 **Utilisateur inscrit :** {user_data['prenom']} {user_data['nom']} ⚡ **Génération automatique disponible** 📄 Cliquez sur le bouton "📄 Télécharger PDF" pour créer votre document personnalisé ✨ **Vos données seront automatiquement remplies dans le contrat**""" self.pages_data['page7'] = pdf_info else: # LaTeX non disponible latex_info = f"""**7 | Validation** 📋 **Je souhaite transmettre ma déclaration** ✅ Par voie électronique 📎 **Documents à joindre** ⚠️ Contrat PDF (LaTeX non disponible) 👤 **Utilisateur inscrit :** {user_data['prenom']} {user_data['nom']} ❌ **LaTeX non installé sur le serveur** 📝 Contactez l'administrateur pour activer la génération PDF 🔧 **Note admin :** LaTeX doit être installé pour la génération PDF""" self.pages_data['page7'] = latex_info else: # Utilisateur non inscrit - afficher instructions d'inscription register_info = f"""**7 | Validation** � **Je souhaite transmettre ma déclaration** ✅ Par voie électronique 📎 **Documents à joindre** 📄 Contrat PDF (génération disponible) �💡 **Génération automatique de PDF disponible !** 📝 **Étape 1 :** Utilisez `/register` pour vous inscrire avec vos données personnelles 🔄 **Étape 2 :** Revenez sur cette page 7 → le PDF personnalisé sera proposé ! ✅ **Alternative :** Cliquez sur "📄 Télécharger PDF" pour un contrat générique""" self.pages_data['page7'] = register_info # Afficher la page 7 mise à jour embed = self.create_page_embed('page7') await interaction.followup.edit_message(interaction.message.id, embed=embed, view=self) # Génération automatique du PDF en arrière-plan asyncio.create_task(self._generate_and_store_pdf_for_page7(interaction)) except Exception as e: logger.error(f"❌ Erreur page 7: {e}") # En cas d'erreur, afficher quand même la page 7 basique self.pages_data['page7'] = f"""**7 | Validation** ❌ **Erreur lors de la préparation de la page** {str(e)} 📄 Utilisez le bouton "📄 Télécharger PDF" ci-dessous""" embed = self.create_page_embed('page7') await interaction.followup.edit_message(interaction.message.id, embed=embed, view=self) async def _generate_and_store_pdf_for_page7(self, interaction): """Génère automatiquement un PDF pour la page 7 et stocke le chemin""" try: user_data = self.bot.user_manager.get_user(self.user_id) if self.user_id else None latex_available = self.bot.contract_generator.check_latex_installation() if not latex_available: logger.warning("⚠️ LaTeX non disponible pour génération PDF automatique") return # Re-scraper les données vidéo video_data = self.bot.scraper.scrape_video(self.url) if not video_data: logger.warning("⚠️ Impossible de récupérer les données vidéo pour PDF") return # Extraire le pseudonyme du créateur def get_creator_pseudo(): """Récupère le pseudonyme du créateur pour le contrat""" # Si l'utilisateur a renseigné son Instagram, l'utiliser if user_data and user_data.get('instagram'): return user_data['instagram'] # Sinon, essayer d'extraire depuis l'URL try: if 'instagram.com' in self.url: # Pour Instagram, essayer d'extraire le créateur de l'URL ou description # Pattern basique pour Instagram import re # Chercher le pattern @username dans l'URL ou les logs return "votre_pseudo" # Placeholder temporaire elif 'youtube.com' in self.url or 'youtu.be' in self.url: return "votre_pseudo_youtube" else: return "votre_pseudo" except Exception as e: logger.warning(f"⚠️ Impossible d'extraire le créateur: {e}") return "votre_pseudo" creator_pseudo = get_creator_pseudo() logger.info(f"🎭 Créateur pour le contrat: {creator_pseudo}") # Générer le contrat seulement pour les utilisateurs inscrits if user_data: # Utilisateur inscrit -> PDF personnalisé logger.info(f"🔄 Génération PDF personnalisé automatique pour {user_data['prenom']} {user_data['nom']}") result = self.bot.contract_generator.generate_contract(user_data, video_data, creator_pseudo, self.url) pdf_type = "Personnalisé" if result['success']: # Stocker le chemin PDF pour le bouton de téléchargement self.pdf_path = result['pdf_path'] self.pdf_filename = result['filename'] self.pdf_type = pdf_type # Mettre à jour la page 7 avec l'info du PDF généré pdf_status = f""" ✅ **PDF {pdf_type} généré automatiquement !** 👤 **Utilisateur :** {user_data['prenom']} {user_data['nom']} 📄 **Fichier :** `{result['filename']}`""" else: pdf_status = f""" ❌ **Erreur lors de la génération du PDF** {result.get('error', 'Erreur inconnue')}""" else: # Pour les utilisateurs non inscrits, pas de PDF pdf_status = "" # Mise à jour silencieuse de la page 7 seulement s'il y a un PDF généré if pdf_status and user_data: current_content = self.pages_data.get('page7', '') if "✅ **PDF" not in current_content: self.pages_data['page7'] = current_content + pdf_status logger.info(f"✅ PDF {pdf_type.lower()} généré et stocké pour téléchargement") except Exception as e: logger.error(f"❌ Erreur génération PDF automatique page 7: {e}") @discord.ui.button(label="📄 Télécharger PDF", style=discord.ButtonStyle.success, emoji="📄") async def download_pdf_button(self, interaction: discord.Interaction, button: discord.ui.Button): """Télécharger le PDF généré automatiquement ou en générer un nouveau""" try: await interaction.response.defer(ephemeral=True) # Vérifier si on a un PDF déjà généré if hasattr(self, 'pdf_path') and self.pdf_path and os.path.exists(self.pdf_path): # PDF déjà généré, l'envoyer directement try: with open(self.pdf_path, 'rb') as f: file = discord.File(f, filename=self.pdf_filename) embed = discord.Embed( title=f"📄 Contrat PDF {self.pdf_type}", description=f"**Lien :** {self.url}\n**Type :** {self.pdf_type}", color=0x00ff00 if self.pdf_type == "Personnalisé" else 0xff9900 ) if self.pdf_type == "Personnalisé" and self.user_id: user_data = self.bot.user_manager.get_user(self.user_id) if user_data: embed.add_field(name="👤 Utilisateur", value=f"{user_data['prenom']} {user_data['nom']}", inline=True) embed.add_field(name="✅ Statut", value="Prêt à utiliser", inline=True) else: embed.add_field(name="⚠️ Action requise", value="Complétez les champs [entre crochets]", inline=False) embed.add_field(name="💡 Conseil", value="Utilisez `/register` pour un PDF automatique", inline=False) embed.add_field(name="🔗 URL", value=self.url, inline=False) embed.set_footer(text="SCAMBot - Document à joindre à votre déclaration SCAM") await interaction.followup.send(embed=embed, file=file) logger.info(f"✅ PDF téléchargé via bouton: {self.pdf_filename}") return except Exception as file_error: logger.error(f"❌ Erreur lecture PDF existant: {file_error}") # Continuer vers la génération d'un nouveau PDF # Pas de PDF ou erreur de lecture -> générer un nouveau user_data = self.bot.user_manager.get_user(self.user_id) if self.user_id else None if not self.bot.contract_generator.check_latex_installation(): await interaction.followup.send("❌ LaTeX non installé sur le serveur. Contactez l'administrateur.") return # Re-scraper la vidéo pour avoir les métadonnées à jour video_data = self.bot.scraper.scrape_video(self.url) if not video_data: await interaction.followup.send("❌ Impossible de récupérer les données de la vidéo.") return # Générer le contrat if user_data: # Obtenir le pseudonyme du créateur creator_pseudo = self.get_creator_pseudo(user_data, video_data.get('platform', 'unknown')) result = self.bot.contract_generator.generate_contract(user_data, video_data, creator_pseudo, self.url) pdf_type = "Personnalisé" color = 0x00ff00 else: fake_user_data = { 'prenom': '[VOTRE PRÉNOM]', 'nom': '[VOTRE NOM]', 'rue': '[VOTRE RUE]', 'code_postal': '[CODE POSTAL]', 'ville': '[VOTRE VILLE]' } result = self.bot.contract_generator.generate_contract(fake_user_data, video_data, "[VOTRE PSEUDONYME]", self.url) pdf_type = "Générique" color = 0xff9900 if result['success']: # Stocker le nouveau PDF self.pdf_path = result['pdf_path'] self.pdf_filename = result['filename'] self.pdf_type = pdf_type # Envoyer le PDF try: with open(result['pdf_path'], 'rb') as f: file = discord.File(f, filename=result['filename']) embed = discord.Embed( title=f"📄 Contrat PDF {pdf_type}", description=f"**Lien :** {self.url}\n**Type :** {pdf_type}", color=color ) if user_data: embed.add_field(name="👤 Utilisateur", value=f"{user_data['prenom']} {user_data['nom']}", inline=True) embed.add_field(name="✅ Statut", value="Prêt à utiliser", inline=True) else: embed.add_field(name="⚠️ Action requise", value="Complétez les champs [entre crochets]", inline=False) embed.add_field(name="💡 Conseil", value="Utilisez `/register` pour un PDF automatique", inline=False) embed.add_field(name="🔗 URL", value=self.url, inline=False) embed.set_footer(text="SCAMBot - Document à joindre à votre déclaration SCAM") await interaction.followup.send(embed=embed, file=file) logger.info(f"✅ Nouveau PDF généré et téléchargé: {result['filename']}") except Exception as file_error: logger.error(f"❌ Erreur envoi nouveau PDF: {file_error}") await interaction.followup.send(f"✅ PDF généré: `{result['filename']}` mais erreur d'envoi: {file_error}") else: await interaction.followup.send(f"❌ Erreur génération PDF: {result['error']}") except Exception as e: logger.error(f"❌ Erreur bouton téléchargement PDF: {e}") await interaction.followup.send(f"❌ Erreur: {str(e)}") @discord.ui.button(label="🔄 Régénérer", style=discord.ButtonStyle.success, emoji="🔄") async def regenerate_button(self, interaction: discord.Interaction, button: discord.ui.Button): """Régénérer complètement le formulaire""" await interaction.response.defer() try: # Toujours re-scraper les données vidéo pour la régénération logger.info(f"🔄 Régénération du formulaire pour {self.url}") video_data = self.bot.scraper.scrape_video(self.url) if not video_data: await interaction.followup.send("❌ Impossible de récupérer les données de la vidéo lors de la régénération", ephemeral=True) return # Régénérer avec les nouvelles données result = self.bot.llm.process_video(video_data) if result['success']: # Mettre à jour les données self.pages_data = result['pages'] self.game_name = result['game_name'] self.video_data = video_data # Mettre à jour les données vidéo # Mettre à jour en base self.bot.db.update_processed_video( video_url=self.url, form_data=result['full_form_data'], game_name=result['game_name'], full_form_data=result['full_form_data'] ) # Afficher la page courante mise à jour embed = self.create_page_embed(self.current_page) await interaction.followup.edit_message(interaction.message.id, embed=embed, view=self) # Notification de succès await interaction.followup.send("✅ Formulaire régénéré avec succès !", ephemeral=True) else: await interaction.followup.send(f"❌ Erreur régénération: {result['error']}", ephemeral=True) except Exception as e: logger.error(f"❌ Erreur régénération: {e}") await interaction.followup.send(f"❌ Erreur: {str(e)}", ephemeral=True) @discord.ui.button(label="📋 Tout afficher", style=discord.ButtonStyle.secondary, emoji="📋") async def show_all_button(self, interaction: discord.Interaction, button: discord.ui.Button): """Afficher toutes les pages dans un seul message""" try: full_content = f"**📋 Déclaration SCAM complète pour {self.game_name}**\n\n" for page_key in ['page1', 'page2', 'page5', 'page6', 'page7']: page_content = self.pages_data.get(page_key, "Contenu non disponible") full_content += f"{page_content}\n\n" full_content += f"🔗 **Lien original:** {self.url}" # Créer un embed ou un fichier selon la taille if len(full_content) > 4000: # Créer un fichier texte import io file_content = full_content.encode('utf-8') file = discord.File(io.BytesIO(file_content), filename=f"scam_form_{self.game_name.replace(' ', '_')}.txt") await interaction.response.send_message("📄 Formulaire complet (trop long pour Discord):", file=file, ephemeral=True) else: # Envoyer en embed embed = discord.Embed( title=f"📋 Formulaire SCAM complet", description=full_content, color=0x9932cc, timestamp=datetime.now() ) embed.set_footer(text="SCAMBot - Swiplay") await interaction.response.send_message(embed=embed, ephemeral=True) except Exception as e: logger.error(f"❌ Erreur affichage complet: {e}") await interaction.response.send_message(f"❌ Erreur: {str(e)}", ephemeral=True) async def on_timeout(self): """Désactiver les boutons après timeout""" for item in self.children: item.disabled = True # Commandes admin (préfixe !) class AdminCommands(commands.Cog): def __init__(self, bot: SCAMBot): self.bot = bot @commands.command(name="addcreator") async def add_creator(self, ctx, pseudo: str, platform: str, profile_url: str, channel_id: int): """Ajoute un créateur à surveiller""" if ctx.author.id not in self.bot.admin_users: await ctx.send("❌ Vous n'avez pas les permissions pour cette commande.") return try: success = self.bot.db.add_creator(pseudo, platform, profile_url, channel_id) if success: embed = discord.Embed( title="✅ Créateur ajouté", description=f"**Pseudo:** {pseudo}\n**Plateforme:** {platform}\n**URL:** {profile_url}\n**Canal:** <#{channel_id}>", color=0x00ff00 ) await ctx.send(embed=embed) else: await ctx.send("❌ Erreur lors de l'ajout du créateur.") except Exception as e: logger.error(f"❌ Erreur commande addcreator: {e}") await ctx.send(f"❌ Erreur: {str(e)}") @commands.command(name="listcreators") async def list_creators(self, ctx): """Liste tous les créateurs surveillés""" if ctx.author.id not in self.bot.admin_users: await ctx.send("❌ Vous n'avez pas les permissions pour cette commande.") return try: creators = self.bot.db.list_creators() if not creators: await ctx.send("📝 Aucun créateur enregistré.") return embed = discord.Embed( title="👥 Créateurs surveillés", color=0x0099ff ) for creator in creators: creator_id, pseudo, platform, profile_url, discord_channel_id, created_at = creator embed.add_field( name=f"🎮 {pseudo}", value=f"**Plateforme:** {platform}\n**URL:** {profile_url}\n**Canal:** <#{discord_channel_id}>\n**Ajouté:** {created_at}", inline=False ) await ctx.send(embed=embed) except Exception as e: logger.error(f"❌ Erreur commande listcreators: {e}") await ctx.send(f"❌ Erreur: {str(e)}") @commands.command(name="removecreator") async def remove_creator(self, ctx, pseudo: str): """Supprime un créateur de la surveillance""" if ctx.author.id not in self.bot.admin_users: await ctx.send("❌ Vous n'avez pas les permissions pour cette commande.") return try: success = self.bot.db.remove_creator(pseudo) if success: embed = discord.Embed( title="✅ Créateur supprimé", description=f"Le créateur **{pseudo}** a été supprimé de la surveillance.", color=0xff0000 ) await ctx.send(embed=embed) else: await ctx.send("❌ Erreur lors de la suppression du créateur.") except Exception as e: logger.error(f"❌ Erreur commande removecreator: {e}") await ctx.send(f"❌ Erreur: {str(e)}") async def main(): """Fonction principale""" # Créer le bot bot = SCAMBot() # Ajouter les commandes slash au bot avant de démarrer @bot.tree.command(name="declare", description="Génère un formulaire SCAM pour une vidéo") @app_commands.describe(url="URL de la vidéo à traiter") async def declare_command_bot(interaction: discord.Interaction, url: str): """Commande /declare pour traiter une vidéo""" try: # Répondre immédiatement pour éviter l'expiration await interaction.response.send_message("🔄 **Traitement en cours...**\nVeuillez patienter, l'analyse de la vidéo peut prendre quelques instants.", ephemeral=True) # Traiter la vidéo de manière asynchrone avec l'ID utilisateur logger.info(f"🔄 Début traitement /declare pour {url} par utilisateur {interaction.user.id}") await bot.process_video_url(url, interaction.channel, user_id=str(interaction.user.id)) # Confirmer que le traitement est terminé try: await interaction.edit_original_response(content="✅ **Traitement terminé !** Voir le formulaire SCAM ci-dessus.") except discord.NotFound: # L'interaction a expiré, ne pas renvoyer le message dans le canal pour éviter le double logger.info("✅ Traitement terminé - interaction expirée mais c'est normal") except Exception as followup_error: logger.info(f"✅ Traitement terminé - {followup_error}") except Exception as e: logger.error(f"❌ Erreur commande declare: {e}") try: if not interaction.response.is_done(): await interaction.response.send_message(f"❌ Erreur: {str(e)}", ephemeral=True) else: await interaction.edit_original_response(content=f"❌ Erreur: {str(e)}") except discord.NotFound: # L'interaction a expiré, c'est normal pour les opérations longues logger.info("ℹ️ Interaction expirée - traitement effectué avec succès") except Exception as final_error: logger.info(f"ℹ️ Fin de traitement - {final_error}") # Ne pas re-envoyer dans le canal car le traitement s'est bien passé @bot.tree.command(name="register", description="S'inscrire ou modifier ses données personnelles pour les déclarations SCAM") async def register_command_bot(interaction: discord.Interaction): """Commande /register pour l'inscription utilisateur""" try: # Vérifier si l'utilisateur existe déjà user_data = bot.user_manager.get_user(str(interaction.user.id)) if user_data: # Utilisateur existant - différer et afficher ses données await interaction.response.defer(ephemeral=True) # Utilisateur existant - afficher ses données embed = discord.Embed( title="👤 Vos données SCAM", description="Vous êtes déjà inscrit. Voici vos données actuelles :", color=0x0099ff, timestamp=discord.utils.utcnow() ) embed.add_field(name="👤 Identité", value=f"{user_data['prenom']} {user_data['nom']}", inline=True) embed.add_field(name="📧 Email", value=user_data['email'], inline=True) embed.add_field(name="📞 Téléphone", value=user_data['telephone'], inline=True) embed.add_field(name="🏠 Adresse", value=f"{user_data['rue']}\n{user_data['code_postal']} {user_data['ville']}", inline=False) embed.add_field(name="📅 Inscrit le", value=user_data['created_at'], inline=True) embed.set_footer(text="SCAMBot - Utilisez les boutons pour modifier ou supprimer vos données") view = UserProfileView(bot, user_data) await interaction.followup.send(embed=embed, view=view, ephemeral=True) else: # Nouvel utilisateur - lancer l'inscription directement (pas de defer car on utilise un modal) modal = UserRegistrationModal(bot) await interaction.response.send_modal(modal) except Exception as e: logger.error(f"❌ Erreur commande register: {e}") try: if not interaction.response.is_done(): await interaction.response.send_message(f"❌ Erreur: {str(e)}", ephemeral=True) else: await interaction.followup.send(f"❌ Erreur: {str(e)}", ephemeral=True) except discord.NotFound: # L'interaction a expiré logger.warning("⚠️ Impossible d'envoyer l'erreur register - interaction expirée") await interaction.channel.send(f"❌ Erreur inscription: {str(e)}") except Exception as final_error: logger.error(f"❌ Impossible d'envoyer l'erreur register: {final_error}") # En dernier recours, envoyer dans le canal try: await interaction.channel.send(f"❌ Erreur inscription: {str(e)}") except: pass @bot.tree.command(name="generate-contract", description="Génère un contrat PDF pour une vidéo (nécessite inscription)") @app_commands.describe(url="URL de la vidéo pour laquelle générer le contrat", creator_pseudo="Votre pseudonyme sur la plateforme (optionnel)") async def generate_contract_command_bot(interaction: discord.Interaction, url: str, creator_pseudo: str = ""): """Commande /generate-contract pour générer un contrat PDF""" try: # Vérifier si l'utilisateur est inscrit user_data = bot.user_manager.get_user(str(interaction.user.id)) if not user_data: embed = discord.Embed( title="❌ Inscription requise", description="Vous devez d'abord vous inscrire avec `/register` pour générer des contrats.", color=0xff0000 ) await interaction.response.send_message(embed=embed, ephemeral=True) return await interaction.response.defer(ephemeral=True) # Vérifier l'installation de LaTeX if not bot.contract_generator.check_latex_installation(): embed = discord.Embed( title="❌ LaTeX non installé", description="LaTeX n'est pas installé sur le serveur. Contactez l'administrateur.", color=0xff0000 ) embed.add_field( name="Installation requise", value=bot.contract_generator.install_latex_packages(), inline=False ) await interaction.followup.send(embed=embed) return # Scraper la vidéo pour récupérer les métadonnées video_data = bot.scraper.scrape_video(url) if not video_data: await interaction.followup.send("❌ Impossible de récupérer les données de la vidéo.") return # Générer le contrat result = bot.contract_generator.generate_contract(user_data, video_data, creator_pseudo, url) if result['success']: # Envoyer le PDF embed = discord.Embed( title="✅ Contrat généré avec succès", description=f"Attestation sur l'honneur pour :\n**{url}**", color=0x00ff00, timestamp=discord.utils.utcnow() ) embed.add_field(name="👤 Auteur", value=f"{user_data['prenom']} {user_data['nom']}", inline=True) embed.add_field(name="📺 Plateforme", value=video_data.get('platform', 'N/A'), inline=True) embed.add_field(name="🔗 URL", value=url, inline=False) embed.set_footer(text="SCAMBot - Document à joindre à votre déclaration SCAM") try: with open(result['pdf_path'], 'rb') as f: file = discord.File(f, filename=result['filename']) await interaction.followup.send(embed=embed, file=file) logger.info(f"✅ Contrat généré et envoyé pour {user_data['prenom']} {user_data['nom']} - {url}") except Exception as file_error: logger.error(f"❌ Erreur envoi fichier: {file_error}") embed.add_field(name="📁 Fichier", value=f"Généré: `{result['filename']}`\n(Erreur d'envoi)", inline=False) await interaction.followup.send(embed=embed) else: await interaction.followup.send(f"❌ Erreur génération contrat: {result['error']}") except Exception as e: logger.error(f"❌ Erreur commande generate-contract: {e}") try: if not interaction.response.is_done(): await interaction.response.send_message(f"❌ Erreur: {str(e)}", ephemeral=True) else: await interaction.followup.send(f"❌ Erreur: {str(e)}") except: pass @bot.tree.command(name="clear-history", description="Vide l'historique des vidéos traitées (Admin uniquement)") @app_commands.describe( confirm="Tapez 'CONFIRMER' pour vider complètement l'historique", creator="Pseudo du créateur (optionnel, vide l'historique d'un créateur spécifique)" ) async def clear_history_command_bot(interaction: discord.Interaction, confirm: str, creator: str = None): """Commande /clear-history pour vider l'historique des données""" try: # Vérifier les permissions admin if interaction.user.id not in bot.admin_users: await interaction.response.send_message("❌ Vous n'avez pas les permissions pour cette commande.", ephemeral=True) return # Vérifier la confirmation if confirm.upper() != "CONFIRMER": await interaction.response.send_message("❌ Vous devez taper exactement 'CONFIRMER' pour valider cette action destructive.", ephemeral=True) return await interaction.response.defer() if creator: # Vider l'historique d'un créateur spécifique creator_data = bot.db.get_creator_by_pseudo(creator) if not creator_data: await interaction.followup.send(f"❌ Créateur '{creator}' non trouvé.", ephemeral=True) return creator_id = creator_data[0] count = bot.db.clear_processed_videos_by_creator(creator_id) if count >= 0: embed = discord.Embed( title="🗑️ Historique vidé (créateur spécifique)", description=f"**Créateur :** {creator}\n**Vidéos supprimées :** {count}", color=0xff6600, timestamp=datetime.now() ) embed.set_footer(text="SCAMBot - Action admin") await interaction.followup.send(embed=embed) else: await interaction.followup.send("❌ Erreur lors de la suppression.", ephemeral=True) else: # Vider tout l'historique count = bot.db.clear_all_processed_videos() if count >= 0: embed = discord.Embed( title="🗑️ Historique complètement vidé", description=f"**Vidéos supprimées :** {count}\n**Statut :** Toutes les données de vidéos traitées ont été supprimées", color=0xff0000, timestamp=datetime.now() ) embed.add_field(name="⚠️ Attention", value="Cette action est irréversible", inline=False) embed.set_footer(text="SCAMBot - Action admin") await interaction.followup.send(embed=embed) else: await interaction.followup.send("❌ Erreur lors de la suppression.", ephemeral=True) except Exception as e: logger.error(f"❌ Erreur commande clear-history: {e}") try: if not interaction.response.is_done(): await interaction.response.send_message(f"❌ Erreur: {str(e)}", ephemeral=True) else: await interaction.followup.send(f"❌ Erreur: {str(e)}", ephemeral=True) except: pass @bot.tree.command(name="stats", description="Affiche les statistiques du bot") async def stats_command_bot(interaction: discord.Interaction): """Commande /stats pour afficher les statistiques""" try: await interaction.response.defer() stats = bot.db.get_stats() embed = discord.Embed( title="📊 Statistiques SCAMBot", color=0x0099ff, timestamp=datetime.now() ) embed.add_field(name="👥 Créateurs", value=stats['creators_count'], inline=True) embed.add_field(name="🎬 Vidéos traitées", value=stats['videos_count'], inline=True) if stats['platform_stats']: platform_text = "\n".join([f"{platform}: {count}" for platform, count in stats['platform_stats']]) embed.add_field(name="📺 Par plateforme", value=platform_text, inline=False) embed.set_footer(text="SCAMBot - Swiplay") await interaction.followup.send(embed=embed) except Exception as e: logger.error(f"❌ Erreur commande stats: {e}") try: if not interaction.response.is_done(): await interaction.response.send_message(f"❌ Erreur: {str(e)}") else: await interaction.followup.send(f"❌ Erreur: {str(e)}") except discord.NotFound: logger.warning("⚠️ Impossible d'envoyer l'erreur stats - interaction expirée") await interaction.channel.send(f"❌ Erreur stats: {str(e)}") except Exception as final_error: logger.error(f"❌ Impossible d'envoyer l'erreur stats: {final_error}") try: await interaction.channel.send(f"❌ Erreur stats: {str(e)}") except: pass @bot.tree.command(name="sync-commands", description="Force la synchronisation des commandes Discord (Admin uniquement)") async def sync_commands_command_bot(interaction: discord.Interaction): """Commande /sync-commands pour synchroniser les commandes Discord""" try: # Vérifier les permissions admin if interaction.user.id not in bot.admin_users: await interaction.response.send_message("❌ Vous n'avez pas les permissions pour cette commande.", ephemeral=True) return await interaction.response.defer(ephemeral=True) # Synchroniser les commandes try: synced = await bot.tree.sync() embed = discord.Embed( title="✅ Commandes synchronisées", description=f"**Nombre de commandes :** {len(synced)}\n**Statut :** Synchronisation réussie", color=0x00ff00, timestamp=datetime.now() ) # Lister les commandes synchronisées if synced: command_list = "\n".join([f"• /{cmd.name}" for cmd in synced]) embed.add_field(name="📋 Commandes disponibles", value=command_list, inline=False) embed.set_footer(text="SCAMBot - Action admin") await interaction.followup.send(embed=embed) logger.info(f"✅ Commandes Discord synchronisées par {interaction.user}: {len(synced)} commandes") except Exception as sync_error: logger.error(f"❌ Erreur synchronisation commandes: {sync_error}") await interaction.followup.send(f"❌ Erreur synchronisation: {str(sync_error)}") except Exception as e: logger.error(f"❌ Erreur commande sync-commands: {e}") try: if not interaction.response.is_done(): await interaction.response.send_message(f"❌ Erreur: {str(e)}", ephemeral=True) else: await interaction.followup.send(f"❌ Erreur: {str(e)}", ephemeral=True) except: pass # Ajouter les commandes await bot.add_cog(AdminCommands(bot)) # Charger le token depuis les variables d'environnement token = os.getenv('DISCORD_TOKEN') if not token: logger.error("❌ Token Discord non trouvé. Définissez la variable DISCORD_TOKEN dans le fichier .env") return # Démarrer le bot try: await bot.start(token) except Exception as e: logger.error(f"❌ Erreur démarrage bot: {e}") if __name__ == "__main__": # Créer les dossiers nécessaires os.makedirs('logs', exist_ok=True) os.makedirs('config', exist_ok=True) os.makedirs('data', exist_ok=True) # Démarrer le bot asyncio.run(main())