Create app.py

app.py

@@ -0,0 +1,301 @@
+from flask import Flask, render_template, request, jsonify, redirect, url_for
+import aiohttp
+import asyncio
+from bs4 import BeautifulSoup
+import random
+import string
+import json
+import threading
+import os
+import time
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor
+
+app = Flask(__name__)
+
+# Configuration globale
+config = {
+    'base_url': "https://ivoire-startup-tracker-edithbrou.replit.app",
+    'accounts_file': "accounts_data.json",
+    'is_running': False,
+    'batch_size': 10,  # Nombre de requêtes parallèles
+    'progress': {
+        'total': 0,
+        'current': 0,
+        'success': 0,
+        'failed': 0,
+        'last_username': '',
+        'last_status': '',
+        'start_time': None,
+        'end_time': None
+    }
+}
+
+# Fonction pour générer un nom d'utilisateur aléatoire
+def generate_random_username(min_length=8, max_length=12):
+    """Génère un nom d'utilisateur aléatoire d'une longueur raisonnable"""
+    length = random.randint(min_length, max_length)
+    return ''.join(random.choice(string.ascii_lowercase) for _ in range(length))
+
+# Fonction pour générer une adresse email aléatoire
+def generate_random_email():
+    """Génère une adresse email aléatoire"""
+    username = ''.join(random.choice(string.ascii_lowercase) for _ in range(12))
+    domains = ["gmail.com", "yahoo.com", "outlook.com", "example.com"]
+    return f"{username}@{random.choice(domains)}"
+
+# Fonction pour générer un mot de passe aléatoire
+def generate_random_password(length=10):
+    """Génère un mot de passe aléatoire avec un mélange de caractères"""
+    chars = string.ascii_letters + string.digits + "!@#$%^&*()-_=+"  # Éviter certains caractères spéciaux qui pourraient causer des problèmes
+    return ''.join(random.choice(chars) for _ in range(length))
+
+# Fonction asynchrone pour créer un compte
+async def create_account_async(session, is_startup_rep=False):
+    """Crée un compte sur le site web de manière asynchrone"""
+    register_url = f"{config['base_url']}/register"
+    
+    try:
+        # Première requête pour récupérer le token CSRF
+        async with session.get(register_url, timeout=10) as response:
+            if response.status != 200:
+                return {'success': False, 'error': f"Erreur lors de l'accès à la page: {response.status}"}
+            
+            html = await response.text()
+            
+            # Extraire le token CSRF
+            soup = BeautifulSoup(html, 'html.parser')
+            csrf_token_input = soup.find('input', {'id': 'csrf_token'})
+            
+            if not csrf_token_input:
+                return {'success': False, 'error': "Impossible de trouver le token CSRF"}
+                
+            csrf_token = csrf_token_input.get('value')
+            
+            # Générer des informations de compte aléatoires
+            username = generate_random_username()
+            email = generate_random_email()
+            password = generate_random_password()
+            
+            # Préparer les données du formulaire
+            form_data = {
+                'csrf_token': csrf_token,
+                'username': username,
+                'email': email,
+                'password': password,
+                'confirm_password': password,
+                'submit': 'Register'
+            }
+            
+            # Ajouter l'option startup rep si nécessaire
+            if is_startup_rep:
+                form_data['is_startup_rep'] = 'y'
+            
+            # Envoyer le formulaire
+            headers = {
+                'Referer': register_url,
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+            }
+            
+            async with session.post(register_url, data=form_data, headers=headers, timeout=15) as response:
+                result = {
+                    'success': response.status == 200 or response.status == 302,
+                    'username': username,
+                    'email': email,
+                    'password': password,
+                    'is_startup_rep': is_startup_rep,
+                    'created_at': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                    'status_code': response.status
+                }
+                
+                return result
+    
+    except asyncio.TimeoutError:
+        return {'success': False, 'error': "Timeout lors de la requête"}
+    except Exception as e:
+        return {'success': False, 'error': str(e)}
+
+# Fonction pour traiter un lot de comptes en parallèle
+async def process_batch(batch_indices, startup_ratio, accounts):
+    """Traite un lot de comptes en parallèle"""
+    async with aiohttp.ClientSession() as session:
+        tasks = []
+        for i in batch_indices:
+            if not config['is_running']:
+                break
+                
+            is_startup = random.random() < startup_ratio
+            tasks.append(create_account_async(session, is_startup_rep=is_startup))
+        
+        if not tasks:
+            return []
+            
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Traiter les résultats
+        batch_results = []
+        for idx, result in zip(batch_indices, results):
+            if isinstance(result, Exception):
+                config['progress']['failed'] += 1
+                config['progress']['last_status'] = f"Échec de la création du compte {idx+1}: {str(result)}"
+            elif result.get('success', False):
+                config['progress']['success'] += 1
+                config['progress']['last_username'] = result['username']
+                config['progress']['last_status'] = f"Compte {idx+1} créé avec succès"
+                accounts.append(result)
+                batch_results.append(result)
+            else:
+                config['progress']['failed'] += 1
+                config['progress']['last_status'] = f"Échec de la création du compte {idx+1}: {result.get('error', 'Erreur inconnue')}"
+            
+            config['progress']['current'] = idx + 1
+        
+        return batch_results
+
+# Fonction principale pour créer des comptes de manière asynchrone
+async def create_accounts_async(num_accounts, startup_ratio=0.3):
+    """Crée plusieurs comptes en parallèle de manière asynchrone"""
+    # Charger les comptes existants
+    accounts = []
+    if os.path.exists(config['accounts_file']):
+        try:
+            with open(config['accounts_file'], 'r') as f:
+                accounts = json.load(f)
+        except:
+            accounts = []
+    
+    # Traiter les comptes par lots
+    batch_size = config['batch_size']
+    for start_idx in range(0, num_accounts, batch_size):
+        if not config['is_running']:
+            break
+            
+        end_idx = min(start_idx + batch_size, num_accounts)
+        batch_indices = list(range(start_idx, end_idx))
+        
+        # Traiter un lot de comptes
+        await process_batch(batch_indices, startup_ratio, accounts)
+        
+        # Enregistrer les données après chaque lot
+        with open(config['accounts_file'], 'w') as f:
+            json.dump(accounts, f, indent=2)
+            
+        # Petite pause pour éviter de surcharger le serveur
+        await asyncio.sleep(1)
+    
+    return accounts
+
+# Fonction pour lancer la création de comptes en arrière-plan
+def create_accounts_background(num_accounts, startup_ratio=0.3):
+    config['progress'] = {
+        'total': num_accounts,
+        'current': 0,
+        'success': 0,
+        'failed': 0,
+        'last_username': '',
+        'last_status': 'Démarrage...',
+        'start_time': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        'end_time': None
+    }
+    
+    # Créer une boucle asyncio dans un nouveau thread
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    
+    try:
+        accounts = loop.run_until_complete(create_accounts_async(num_accounts, startup_ratio))
+        
+        # Mise à jour finale
+        config['progress']['end_time'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        config['progress']['last_status'] = "Terminé"
+        
+        # Enregistrement final
+        with open(config['accounts_file'], 'w') as f:
+            json.dump(accounts, f, indent=2)
+            
+    except Exception as e:
+        config['progress']['last_status'] = f"Erreur: {str(e)}"
+    finally:
+        config['is_running'] = False
+        loop.close()
+
+# Routes Flask
+@app.route('/')
+def index():
+    return render_template('index.html', config=config)
+
+@app.route('/start', methods=['POST'])
+def start():
+    if config['is_running']:
+        return jsonify({"status": "error", "message": "Une génération est déjà en cours"})
+    
+    num_accounts = int(request.form.get('num_accounts', 10))
+    startup_ratio = float(request.form.get('startup_ratio', 0.3))
+    batch_size = int(request.form.get('batch_size', config['batch_size']))
+    
+    # Mettre à jour la taille du lot
+    config['batch_size'] = min(batch_size, 20)  # Limiter à 20 pour éviter de surcharger le serveur
+    config['is_running'] = True
+    
+    # Démarrer le processus en arrière-plan
+    thread = threading.Thread(target=create_accounts_background, args=(num_accounts, startup_ratio))
+    thread.daemon = True
+    thread.start()
+    
+    return jsonify({"status": "success", "message": "Génération démarrée"})
+
+@app.route('/stop', methods=['POST'])
+def stop():
+    config['is_running'] = False
+    return jsonify({"status": "success", "message": "Arrêt demandé"})
+
+@app.route('/progress')
+def progress():
+    return jsonify(config['progress'])
+
+@app.route('/accounts')
+def view_accounts():
+    page = int(request.args.get('page', 1))
+    per_page = 20
+    
+    accounts = []
+    if os.path.exists(config['accounts_file']):
+        try:
+            with open(config['accounts_file'], 'r') as f:
+                accounts = json.load(f)
+        except:
+            accounts = []
+            
+    total_accounts = len(accounts)
+    total_pages = (total_accounts + per_page - 1) // per_page
+    
+    start_idx = (page - 1) * per_page
+    end_idx = start_idx + per_page
+    
+    current_accounts = accounts[start_idx:end_idx]
+    
+    return render_template(
+        'accounts.html',
+        accounts=current_accounts,
+        page=page,
+        total_pages=total_pages,
+        total_accounts=total_accounts
+    )
+
+@app.route('/script.js')
+def serve_js():
+    return render_template('script.js'), 200, {'Content-Type': 'application/javascript'}
+
+@app.route('/clear', methods=['POST'])
+def clear_accounts():
+    """Supprime tous les comptes enregistrés"""
+    if os.path.exists(config['accounts_file']):
+        try:
+            os.remove(config['accounts_file'])
+            return jsonify({"status": "success", "message": "Données des comptes supprimées"})
+        except Exception as e:
+            return jsonify({"status": "error", "message": f"Erreur lors de la suppression: {str(e)}"})
+    return jsonify({"status": "success", "message": "Aucun fichier à supprimer"})
+
+if __name__ == '__main__':
+    app.run(debug=True)