Update app.py

app.py

@@ -1,6 +1,4 @@
 from flask import Flask, render_template, request, jsonify, redirect, url_for
-import requests
-from bs4 import BeautifulSoup
 import random
 import string
 import json
@@ -9,6 +7,14 @@ import os
 import time
 from datetime import datetime
 
+# --- Selenium Imports ---
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.chrome.service import Service as ChromeService
+from webdriver_manager.chrome import ChromeDriverManager
+
 app = Flask(__name__)
 
 # Configuration globale
@@ -28,85 +34,96 @@ config = {
     }
 }
 
-# Fonction pour générer un nom d'utilisateur aléatoire (min 80 caractères)
-def generate_random_username(min_length=80, max_length=100):
-    """Génère un nom d'utilisateur aléatoire d'au moins 80 caractères"""
+# Fonction pour générer un nom d'utilisateur aléatoire (min 3 caractères)
+def generate_random_username(min_length=3, max_length=10):  # Adjusted min_length
+    """Génère un nom d'utilisateur aléatoire d'au moins 3 caractères"""
     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))
+    """Génère une adresse email aléatoire au format plus standard"""
+    username = ''.join(random.choice(string.ascii_lowercase) for _ in range(7))
     domains = ["gmail.com", "yahoo.com", "outlook.com", "example.com"]
-    return f"{username}@{random.choice(domains)}"
+    return f"{username}+{int(time.time())}@{random.choice(domains)}" # Added timestamp
 
 # Fonction pour générer un mot de passe aléatoire
-def generate_random_password(length=8):
-    """Génère un mot de passe aléatoire composé de chiffres de 1 à 8."""
-    chars = string.digits[1:9]  # Digits from 1 to 8 (inclusive)
+def generate_random_password(min_length=6, max_length=12):  # Adjusted min_length
+    """Génère un mot de passe aléatoire"""
+    chars = string.ascii_letters + string.digits + "!@#$%^&*"
+    length = random.randint(min_length, max_length)
     return ''.join(random.choice(chars) for _ in range(length))
+
 # Fonction pour créer un compte
 def create_account(is_startup_rep=False):
-    """Crée un compte sur le site web"""
+    """Crée un compte sur le site web en utilisant Selenium"""
     register_url = f"{config['base_url']}/register"
-    
-    # Première requête pour récupérer le token CSRF
-    session = requests.Session()
+
+    # Use webdriver_manager to handle ChromeDriver
+    service = ChromeService(executable_path=ChromeDriverManager().install())
+    options = webdriver.ChromeOptions()
+    options.add_argument('--headless') # Run in headless mode (no GUI)
+    options.add_argument('--no-sandbox') # Needed for Replit/containers
+    options.add_argument('--disable-dev-shm-usage') # Also for Replit
+
+    driver = webdriver.Chrome(service=service, options=options)
+
     try:
-        response = session.get(register_url)
-        
-        if response.status_code != 200:
-            return {'success': False, 'error': f"Erreur lors de l'accès à la page: {response.status_code}"}
-        
-        # Extraire le token CSRF
-        soup = BeautifulSoup(response.text, 'html.parser')
-        csrf_token = soup.find('input', {'id': 'csrf_token'}).get('value')
-        
-        if not csrf_token:
-            return {'success': False, 'error': "Impossible de trouver le token CSRF"}
-        
-        # Générer des informations de compte aléatoires
+        driver.get(register_url)
+
+        # Wait for the form to be present (important for dynamic pages)
+        WebDriverWait(driver, 10).until(
+            EC.presence_of_element_located((By.ID, "username"))
+        )
+
+        # Generate random account data
         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
+
+        # Fill out the form fields
+        driver.find_element(By.ID, "username").send_keys(username)
+        driver.find_element(By.ID, "email").send_keys(email)
+        driver.find_element(By.ID, "password").send_keys(password)
+        driver.find_element(By.ID, "confirm_password").send_keys(password)
+
         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'
-        }
-        
-        response = session.post(register_url, data=form_data, headers=headers)
+            driver.find_element(By.ID, "is_startup_rep").click()
+
+        # Submit the form
+        driver.find_element(By.ID, "submit").click()
+
+        # Wait for a result (either success or failure) - Adjust the wait time as needed
+        # We'll check for redirection as an indicator of success.  A more robust check
+        # might involve looking for specific success/error messages on the resulting page.
+        WebDriverWait(driver, 10).until(
+            EC.url_changes(register_url)
+        )
         
+        # Check if redirection occurred to a URL other than the registration URL
+        current_url = driver.current_url
+        if current_url != register_url:
+            success = True
+        else:
+             success = False # Explicitly set to False
+
+
         result = {
-            'success': response.status_code == 200 or response.status_code == 302,
+            'success': success,
             '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_code
         }
-        
+
         return result
-    
+
     except Exception as e:
+        print(f"Selenium Error: {e}")  # Log the Selenium error
         return {'success': False, 'error': str(e)}
+    finally:
+        driver.quit()  # Always close the browser
 
 # Fonction pour créer plusieurs comptes en arrière-plan
 def create_accounts_background(num_accounts, startup_ratio=0.3):
@@ -165,6 +182,7 @@ def create_accounts_background(num_accounts, startup_ratio=0.3):
     with open(config['accounts_file'], 'w') as f:
         json.dump(accounts, f, indent=2)
 
+
 # Routes Flask
 @app.route('/')
 def index():
@@ -174,17 +192,17 @@ def index():
 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))
-    
+
     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'])
@@ -200,7 +218,7 @@ def progress():
 def view_accounts():
     page = int(request.args.get('page', 1))
     per_page = 20
-    
+
     accounts = []
     if os.path.exists(config['accounts_file']):
         try:
@@ -208,15 +226,15 @@ def view_accounts():
                 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,
@@ -230,6 +248,5 @@ def view_accounts():
 def serve_js():
     return render_template('script.js'), 200, {'Content-Type': 'application/javascript'}
 
-
 if __name__ == '__main__':
-    app.run(debug=True)
+    app.run(debug=True) # Keep debug=True for development