Update app.py

app.py

@@ -1,4 +1,6 @@
 from flask import Flask, render_template, request, jsonify, redirect, url_for
+import requests
+from bs4 import BeautifulSoup
 import random
 import string
 import json
@@ -7,14 +9,6 @@ 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
@@ -34,96 +28,86 @@ config = {
     }
 }
 
-# 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"""
+# Fonction pour générer un nom d'utilisateur aléatoire (longueur normale)
+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 au format plus standard"""
-    username = ''.join(random.choice(string.ascii_lowercase) for _ in range(7))
+    """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}+{int(time.time())}@{random.choice(domains)}" # Added timestamp
+    return f"{username}@{random.choice(domains)}"
 
 # Fonction pour générer un mot de passe aléatoire
-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)
+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 + string.punctuation
     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 en utilisant Selenium"""
+    """Crée un compte sur le site web"""
     register_url = f"{config['base_url']}/register"
-
-    # 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)
-
+    
+    # Première requête pour récupérer le token CSRF
+    session = requests.Session()
     try:
-        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
+        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
         username = generate_random_username()
         email = generate_random_email()
         password = generate_random_password()
-
-        # 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)
-
+        
+        # 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:
-            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)
-        )
+            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)
         
-        # 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': success,
+            'success': response.status_code == 200 or response.status_code == 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_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):
@@ -182,7 +166,6 @@ 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():
@@ -192,17 +175,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'])
@@ -218,7 +201,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:
@@ -226,15 +209,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,
@@ -243,10 +226,9 @@ def view_accounts():
         total_accounts=total_accounts
     )
 
-
 @app.route('/script.js')
 def serve_js():
     return render_template('script.js'), 200, {'Content-Type': 'application/javascript'}
 
 if __name__ == '__main__':
-    app.run(debug=True) # Keep debug=True for development
+    app.run(debug=True)