Update app.py

app.py

@@ -1,6 +1,5 @@
 import os
 import re
-import sqlite3
 import requests
 import pandas as pd
 from datetime import datetime
@@ -14,60 +13,11 @@ from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 import logging
 import json
+from sqlalchemy import create_engine, func
+from sqlalchemy.orm import sessionmaker
+from schema import Base, Project, Campaign, Lead, LeadSource, CampaignLead, EmailCampaign, SearchTerm, KnowledgeBase, EmailTemplate, OptimizedSearchTerm, SearchTermEffectiveness, SearchTermGroup, AIRequestLog, AutomationLog
 
-# Configuration
-AWS_ACCESS_KEY_ID = "AKIASO2XOMEGIVD422N7"
-AWS_SECRET_ACCESS_KEY = "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"
-REGION_NAME = "us-east-1"
-
-OPENAI_API_KEY ="sk-1234"
-OPENAI_API_BASE = "https://openai-proxy-kl3l.onrender.com"
-OPENAI_MODEL = "gpt-3.5-turbo"
-
-# SQLite configuration
-sqlite_db_path = "autoclient.db"
-
-
-# Ensure the database file exists
-try:
-    if not os.path.exists(sqlite_db_path):
-        open(sqlite_db_path, 'w').close()
-except IOError as e:
-    logging.error(f"Failed to create database file: {e}")
-    raise
-
-# Initialize AWS SES client
-try:
-    ses_client = boto3.client('ses',
-                              aws_access_key_id="AKIASO2XOMEGIVD422N7",
-                              aws_secret_access_key="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",
-                              region_name="us-east-1")
-except (NoCredentialsError, PartialCredentialsError) as e:
-    logging.error(f"AWS SES client initialization failed: {e}")
-    raise
-
-# SQLite connection
-def get_db_connection():
-    try:
-        return sqlite3.connect(sqlite_db_path)
-    except sqlite3.Error as e:
-        logging.error(f"Database connection failed: {e}")
-        raise
-
-# HTTP session with retry strategy
-session = requests.Session()
-retries = Retry(total=5, backoff_factor=1, status_forcelist=[502, 503, 504])
-session.mount('https://', HTTPAdapter(max_retries=retries))
-
-# Setup logging
-try:
-    logging.basicConfig(level=logging.INFO, filename='app.log', filemode='a',
-                        format='%(asctime)s - %(levelname)s - %(message)s')
-except IOError as e:
-    print(f"Error setting up logging: {e}")
-    raise
-
-# Input validation functions
+# Validation functions
 def validate_name(name):
     if not name or not name.strip():
         raise ValueError("Name cannot be empty or just whitespace")
@@ -105,111 +55,84 @@ def validate_num_results(num_results):
         raise ValueError("Invalid number of results")
     return num_results
 
-# Initialize database
-def init_db():
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.executescript('''
-    CREATE TABLE IF NOT EXISTS projects (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        project_name TEXT NOT NULL,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-    );
-
-    CREATE TABLE IF NOT EXISTS campaigns (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        campaign_name TEXT NOT NULL,
-        project_id INTEGER,
-        campaign_type TEXT NOT NULL,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        FOREIGN KEY (project_id) REFERENCES projects (id)
-    );
-
-    CREATE TABLE IF NOT EXISTS message_templates (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        template_name TEXT NOT NULL,
-        subject TEXT,
-        body_content TEXT NOT NULL,
-        campaign_id INTEGER,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        FOREIGN KEY (campaign_id) REFERENCES campaigns (id)
-    );
-
-    CREATE TABLE IF NOT EXISTS leads (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        email TEXT,
-        phone TEXT,
-        first_name TEXT,
-        last_name TEXT,
-        company TEXT,
-        job_title TEXT,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-    );
-
-    CREATE TABLE IF NOT EXISTS lead_sources (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        lead_id INTEGER,
-        search_query TEXT,
-        url TEXT,
-        page_title TEXT,
-        meta_description TEXT,
-        http_status INTEGER,
-        scrape_duration TEXT,
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        FOREIGN KEY (lead_id) REFERENCES leads (id)
-    );
-
-    CREATE TABLE IF NOT EXISTS campaign_leads (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        campaign_id INTEGER,
-        lead_id INTEGER,
-        status TEXT DEFAULT 'active',
-        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-        FOREIGN KEY (campaign_id) REFERENCES campaigns (id),
-        FOREIGN KEY (lead_id) REFERENCES leads (id)
-    );
-
-    CREATE TABLE IF NOT EXISTS messages (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        campaign_id INTEGER,
-        lead_id INTEGER,
-        template_id INTEGER,
-        customized_subject TEXT,
-        customized_content TEXT,
-        sent_at TIMESTAMP,
-        status TEXT DEFAULT 'pending',
-        engagement_data TEXT,
-        FOREIGN KEY (campaign_id) REFERENCES campaigns (id),
-        FOREIGN KEY (lead_id) REFERENCES leads (id),
-        FOREIGN KEY (template_id) REFERENCES message_templates (id)
-    );
-
-    CREATE TABLE IF NOT EXISTS search_terms (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        term TEXT NOT NULL,
-        status TEXT DEFAULT 'pending',
-        processed_leads INTEGER DEFAULT 0,
-        last_processed_at TIMESTAMP,
-        campaign_id INTEGER,
-        FOREIGN KEY (campaign_id) REFERENCES campaigns (id)
-    );
-    ''')
-    conn.commit()
-    conn.close()
-    logging.info("Database initialized successfully!")
-
-# Call this at the start of your script
-init_db()
+def sanitize_html(content):
+    return re.sub('<[^<]+?>', '', content)
+
+def find_emails(html_text):
+    email_regex = re.compile(r'\b[A-Za-z0-9._%+-]+@[^@]+\.[A-Z|a-z]{2,7}\b')
+    all_emails = set(email_regex.findall(html_text))
+    valid_emails = {email for email in all_emails if is_valid_email(email)}
+
+    unique_emails = {}
+    for email in valid_emails:
+        domain = email.split('@')[1]
+        if domain not in unique_emails:
+            unique_emails[domain] = email
+
+    return set(unique_emails.values())
+
+def is_valid_email(email):
+    invalid_patterns = [
+        r'\.png', r'\.jpg', r'\.jpeg', r'\.gif', r'\.bmp', r'^no-reply@',
+        r'^prueba@', r'^\d+[a-z]*@'
+    ]
+    typo_domains = ["gmil.com", "gmal.com", "gmaill.com", "gnail.com"]
+    if len(email) < 6 or len(email) > 254:
+        return False
+    for pattern in invalid_patterns:
+        if re.search(pattern, email, re.IGNORECASE):
+            return False
+    domain = email.split('@')[1]
+    if domain in typo_domains or not re.match(r"^[A-Za-z0-9.-]+\.[A-Za-z]{2,}$", domain):
+        return False
+    return True
+
+# Configuration
+aws_access_key_id = os.getenv("AWS_ACCESS_KEY_ID", "default_aws_access_key_id")
+aws_secret_access_key = os.getenv("AWS_SECRET_ACCESS_KEY", "default_aws_secret_access_key")
+region_name = "us-east-1"
+
+openai.api_key = os.getenv("OPENAI_API_KEY", "default_openai_api_key")
+openai.api_base = os.getenv("OPENAI_API_BASE", "http://127.0.0.1:11434/v1")
+openai_model = "mistral"
+
+# Database configuration
+DATABASE_URL = f"postgresql://{os.getenv('SUPABASE_DB_USER')}:{os.getenv('SUPABASE_DB_PASSWORD')}@{os.getenv('SUPABASE_DB_HOST')}:{os.getenv('SUPABASE_DB_PORT')}/{os.getenv('SUPABASE_DB_NAME')}"
+engine = create_engine(DATABASE_URL)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+# Initialize AWS SES client
+try:
+    ses_client = boto3.client('ses',
+                              aws_access_key_id=aws_access_key_id,
+                              aws_secret_access_key=aws_secret_access_key,
+                              region_name=region_name)
+except (NoCredentialsError, PartialCredentialsError) as e:
+    logging.error(f"AWS SES client initialization failed: {e}")
+    raise
+
+# HTTP session with retry strategy
+session = requests.Session()
+retries = Retry(total=5, backoff_factor=1, status_forcelist=[502, 503, 504])
+session.mount('https://', HTTPAdapter(max_retries=retries))
+
+# Setup logging
+try:
+    logging.basicConfig(level=logging.INFO, filename='app.log', filemode='a',
+                        format='%(asctime)s - %(levelname)s - %(message)s')
+except IOError as e:
+    print(f"Error setting up logging: {e}")
+    raise
 
 # Function to create a new project
 def create_project(project_name):
     project_name = validate_name(project_name)
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute("INSERT INTO projects (project_name) VALUES (?)", (project_name,))
-    project_id = cursor.lastrowid
-    conn.commit()
-    conn.close()
+    db = SessionLocal()
+    new_project = Project(project_name=project_name)
+    db.add(new_project)
+    db.commit()
+    project_id = new_project.id
+    db.close()
     return project_id
 
 # Function to create a new campaign
@@ -217,13 +140,12 @@ def create_campaign(campaign_name, project_id, campaign_type):
     campaign_name = validate_name(campaign_name)
     project_id = validate_id(project_id, "project")
     campaign_type = validate_campaign_type(campaign_type)
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute("INSERT INTO campaigns (campaign_name, project_id, campaign_type) VALUES (?, ?, ?)",
-                   (campaign_name, project_id, campaign_type))
-    campaign_id = cursor.lastrowid
-    conn.commit()
-    conn.close()
+    db = SessionLocal()
+    new_campaign = Campaign(campaign_name=campaign_name, project_id=project_id, campaign_type=campaign_type)
+    db.add(new_campaign)
+    db.commit()
+    campaign_id = new_campaign.id
+    db.close()
     return campaign_id
 
 # Function to create a new message template
@@ -232,93 +154,80 @@ def create_message_template(template_name, subject, body_content, campaign_id):
     subject = validate_name(subject)
     body_content = sanitize_html(body_content)
     campaign_id = validate_id(campaign_id, "campaign")
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute("""
-        INSERT INTO message_templates (template_name, subject, body_content, campaign_id)
-        VALUES (?, ?, ?, ?)
-    """, (template_name, subject, body_content, campaign_id))
-    template_id = cursor.lastrowid
-    conn.commit()
-    conn.close()
+    db = SessionLocal()
+    new_template = EmailTemplate(template_name=template_name, subject=subject, body_content=body_content, campaign_id=campaign_id)
+    db.add(new_template)
+    db.commit()
+    template_id = new_template.id
+    db.close()
     return template_id
 
 # Function to add a new search term
 def add_search_term(term, campaign_id):
     term = validate_name(term)
     campaign_id = validate_id(campaign_id, "campaign")
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute("INSERT INTO search_terms (term, campaign_id) VALUES (?, ?)", (term, campaign_id))
-    term_id = cursor.lastrowid
-    conn.commit()
-    conn.close()
+    db = SessionLocal()
+    new_term = SearchTerm(term=term, campaign_id=campaign_id)
+    db.add(new_term)
+    db.commit()
+    term_id = new_term.id
+    db.close()
     return term_id
 
 # Function to fetch search terms
 def fetch_search_terms(campaign_id=None):
-    conn = get_db_connection()
-    cursor = conn.cursor()
+    db = SessionLocal()
+    query = db.query(SearchTerm.id, SearchTerm.term, func.count(LeadSource.id).label('processed_leads'), SearchTerm.category.label('status'))
+    query = query.outerjoin(LeadSource)
     if campaign_id:
         campaign_id = validate_id(campaign_id, "campaign")
-        cursor.execute('SELECT id, term, processed_leads, status FROM search_terms WHERE campaign_id = ?', (campaign_id,))
-    else:
-        cursor.execute('SELECT id, term, processed_leads, status FROM search_terms')
-    rows = cursor.fetchall()
-    conn.close()
-    return pd.DataFrame(rows, columns=["ID", "Search Term", "Leads Fetched", "Status"])
+        query = query.filter(SearchTerm.campaign_id == campaign_id)
+    query = query.group_by(SearchTerm.id)
+    rows = query.all()
+    db.close()
+    return pd.DataFrame([(row.id, row.term, row.processed_leads, row.status) for row in rows], columns=["ID", "Search Term", "Leads Fetched", "Status"])
 
 # Function to update search term status
 def update_search_term_status(term_id, new_status, processed_leads):
     term_id = validate_id(term_id, "search term")
     new_status = validate_status(new_status, ["pending", "completed"])
     processed_leads = validate_num_results(processed_leads)
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute("""
-        UPDATE search_terms
-        SET status = ?, processed_leads = ?, last_processed_at = CURRENT_TIMESTAMP
-        WHERE id = ?
-    """, (new_status, processed_leads, term_id))
-    conn.commit()
-    conn.close()
+    db = SessionLocal()
+    term = db.query(SearchTerm).filter(SearchTerm.id == term_id).first()
+    if term:
+        term.category = new_status
+        db.commit()
+    db.close()
 
 # Function to save a new lead
 def save_lead(email, phone, first_name, last_name, company, job_title):
     email = validate_email(email)
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute("""
-        INSERT INTO leads (email, phone, first_name, last_name, company, job_title)
-        VALUES (?, ?, ?, ?, ?, ?)
-    """, (email, phone, first_name, last_name, company, job_title))
-    lead_id = cursor.lastrowid
-    conn.commit()
-    conn.close()
+    db = SessionLocal()
+    new_lead = Lead(email=email, phone=phone, first_name=first_name, last_name=last_name, company=company, job_title=job_title)
+    db.add(new_lead)
+    db.commit()
+    lead_id = new_lead.id
+    db.close()
     return lead_id
 
 # Function to save lead source
 def save_lead_source(lead_id, search_query, url, page_title, meta_description, http_status, scrape_duration):
     lead_id = validate_id(lead_id, "lead")
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute("""
-        INSERT INTO lead_sources (lead_id, search_query, url, page_title, meta_description, http_status, scrape_duration)
-        VALUES (?, ?, ?, ?, ?, ?, ?)
-    """, (lead_id, search_query, url, page_title, meta_description, http_status, scrape_duration))
-    conn.commit()
-    conn.close()
+    db = SessionLocal()
+    new_lead_source = LeadSource(lead_id=lead_id, url=url, page_title=page_title, meta_description=meta_description, http_status=http_status, scrape_duration=scrape_duration)
+    db.add(new_lead_source)
+    db.commit()
+    db.close()
 
 # Function to add a lead to a campaign
 def add_lead_to_campaign(campaign_id, lead_id):
     campaign_id = validate_id(campaign_id, "campaign")
     lead_id = validate_id(lead_id, "lead")
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute("INSERT OR IGNORE INTO campaign_leads (campaign_id, lead_id) VALUES (?, ?)",
-                   (campaign_id, lead_id))
-    conn.commit()
-    conn.close()
+    db = SessionLocal()
+    new_campaign_lead = CampaignLead(campaign_id=campaign_id, lead_id=lead_id, status='active')
+    db.add(new_campaign_lead)
+    db.commit()
+    db.close()
 
 # Function to create a new message
 def create_message(campaign_id, lead_id, template_id, customized_subject, customized_content):
@@ -327,62 +236,51 @@ def create_message(campaign_id, lead_id, template_id, customized_subject, custom
     template_id = validate_id(template_id, "template")
     customized_subject = validate_name(customized_subject)
     customized_content = sanitize_html(customized_content)
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute("""
-        INSERT INTO messages (campaign_id, lead_id, template_id, customized_subject, customized_content)
-        VALUES (?, ?, ?, ?, ?)
-    """, (campaign_id, lead_id, template_id, customized_subject, customized_content))
-    message_id = cursor.lastrowid
-    conn.commit()
-    conn.close()
+    db = SessionLocal()
+    new_message = EmailCampaign(campaign_id=campaign_id, lead_id=lead_id, template_id=template_id, customized_subject=customized_subject, customized_content=customized_content)
+    db.add(new_message)
+    db.commit()
+    message_id = new_message.id
+    db.close()
     return message_id
 
 # Function to update message status
 def update_message_status(message_id, status, sent_at=None):
     message_id = validate_id(message_id, "message")
     status = validate_status(status, ["pending", "sent", "failed"])
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    if sent_at:
-        cursor.execute("UPDATE messages SET status = ?, sent_at = ? WHERE id = ?",
-                       (status, sent_at, message_id))
-    else:
-        cursor.execute("UPDATE messages SET status = ? WHERE id = ?",
-                       (status, message_id))
-    conn.commit()
-    conn.close()
+    db = SessionLocal()
+    message = db.query(EmailCampaign).filter(EmailCampaign.id == message_id).first()
+    if message:
+        message.status = status
+        if sent_at:
+            message.sent_at = sent_at
+        db.commit()
+    db.close()
 
 # Function to fetch message templates
 def fetch_message_templates(campaign_id=None):
-    conn = get_db_connection()
-    cursor = conn.cursor()
+    db = SessionLocal()
+    query = db.query(EmailTemplate.id, EmailTemplate.template_name)
     if campaign_id:
         campaign_id = validate_id(campaign_id, "campaign")
-        cursor.execute('SELECT id, template_name FROM message_templates WHERE campaign_id = ?', (campaign_id,))
-    else:
-        cursor.execute('SELECT id, template_name FROM message_templates')
-    rows = cursor.fetchall()
-    conn.close()
-    return [f"{row[0]}: {row[1]}" for row in rows]
+        query = query.filter(EmailTemplate.campaign_id == campaign_id)
+    templates = query.all()
+    db.close()
+    return [f"{template.id}: {template.template_name}" for template in templates]
 
 # Function to fetch projects
 def fetch_projects():
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute('SELECT id, project_name FROM projects')
-    rows = cursor.fetchall()
-    conn.close()
-    return [f"{row[0]}: {row[1]}" for row in rows]
+    db = SessionLocal()
+    projects = db.query(Project.id, Project.project_name).all()
+    db.close()
+    return [f"{project.id}: {project.project_name}" for project in projects]
 
 # Function to fetch campaigns
 def fetch_campaigns():
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute('SELECT id, campaign_name FROM campaigns')
-    campaigns = cursor.fetchall()
-    conn.close()
-    return [f"{campaign[0]}: {campaign[1]}" for campaign in campaigns]
+    db = SessionLocal()
+    campaigns = db.query(Campaign.id, Campaign.campaign_name).all()
+    db.close()
+    return [f"{campaign.id}: {campaign.campaign_name}" for campaign in campaigns]
 
 # Bulk search function
 async def bulk_search(selected_terms, num_results, progress=gr.Progress()):
@@ -391,11 +289,13 @@ async def bulk_search(selected_terms, num_results, progress=gr.Progress()):
     num_results = validate_num_results(num_results)
     total_leads = 0
     for term_id in selected_terms:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-        cursor.execute('SELECT term, processed_leads FROM search_terms WHERE id = ?', (term_id,))
-        term, processed_leads = cursor.fetchone()
-        conn.close()
+        db = SessionLocal()
+        term = db.query(SearchTerm.term, func.count(LeadSource.id).label('processed_leads')).outerjoin(LeadSource).filter(SearchTerm.id == term_id).first()
+        db.close()
+        if term:
+            term, processed_leads = term.term, term.processed_leads
+        else:
+            continue
 
         leads_found = 0
         try:
@@ -439,16 +339,9 @@ async def bulk_send(template_id, from_email, reply_to, progress=gr.Progress()):
         raise ValueError("Invalid from email address")
     if not re.match(r"[^@]+@[^@]+\.[^@]+", reply_to):
         raise ValueError("Invalid reply to email address")
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute('''
-        SELECT m.id, l.email, m.customized_subject, m.customized_content
-        FROM messages m
-        JOIN leads l ON m.lead_id = l.id
-        WHERE m.template_id = ? AND m.status = 'pending'
-    ''', (template_id,))
-    messages = cursor.fetchall()
-    conn.close()
+    db = SessionLocal()
+    messages = db.query(EmailCampaign.id, Lead.email, EmailCampaign.customized_subject, EmailCampaign.customized_content).join(Lead).filter(EmailCampaign.template_id == template_id, EmailCampaign.status == 'pending').all()
+    db.close()
 
     total_sent = 0
     for message_id, email, subject, content in messages:
@@ -477,11 +370,9 @@ def get_email_preview(template_id, from_email, reply_to):
     template_id = validate_id(template_id, "template")
     from_email = validate_email(from_email)
     reply_to = validate_email(reply_to)
-    conn = get_db_connection()
-    cursor = conn.cursor()
-    cursor.execute('SELECT subject, body_content FROM message_templates WHERE id = ?', (template_id,))
-    template = cursor.fetchone()
-    conn.close()
+    db = SessionLocal()
+    template = db.query(EmailTemplate.subject, EmailTemplate.body_content).filter(EmailTemplate.id == template_id).first()
+    db.close()
 
     if template:
         subject, body_content = template
@@ -490,41 +381,6 @@ def get_email_preview(template_id, from_email, reply_to):
     else:
         return "Template not found"
 
-# Function to sanitize HTML content
-def sanitize_html(content):
-    return re.sub('<[^<]+?>', '', content)
-
-# Function to find valid emails in HTML text
-def find_emails(html_text):
-    email_regex = re.compile(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b')
-    all_emails = set(email_regex.findall(html_text))
-    valid_emails = {email for email in all_emails if is_valid_email(email)}
-
-    unique_emails = {}
-    for email in valid_emails:
-        domain = email.split('@')[1]
-        if domain not in unique_emails:
-            unique_emails[domain] = email
-
-    return set(unique_emails.values())
-
-# Function to validate email address
-def is_valid_email(email):
-    invalid_patterns = [
-        r'\.png', r'\.jpg', r'\.jpeg', r'\.gif', r'\.bmp', r'^no-reply@',
-        r'^prueba@', r'^\d+[a-z]*@'
-    ]
-    typo_domains = ["gmil.com", "gmal.com", "gmaill.com", "gnail.com"]
-    if len(email) < 6 or len(email) > 254:
-        return False
-    for pattern in invalid_patterns:
-        if re.search(pattern, email, re.IGNORECASE):
-            return False
-    domain = email.split('@')[1]
-    if domain in typo_domains or not re.match(r"^[A-Za-z0-9.-]+\.[A-Za-z]{2,}$", domain):
-        return False
-    return True
-
 # Function to refresh search terms
 def refresh_search_terms(campaign_id):
     return df_to_list(fetch_search_terms(campaign_id))
@@ -546,9 +402,31 @@ def manual_search(term, num_results):
         logging.error(f"Error in manual search: {e}")
     return results[:num_results]
 
+# Add a function to fetch leads
+def fetch_leads():
+    db = SessionLocal()
+    leads = db.query(Lead.id, Lead.email, Lead.first_name, Lead.last_name, Lead.company, Lead.job_title).all()
+    db.close()
+    return pd.DataFrame([(lead.id, lead.email, lead.first_name, lead.last_name, lead.company, lead.job_title) for lead in leads], columns=["ID", "Email", "First Name", "Last Name", "Company", "Job Title"])
+
+# Add a function to fetch campaigns with leads count
+def fetch_campaigns_with_leads():
+    db = SessionLocal()
+    campaigns = db.query(Campaign.id, Campaign.campaign_name, func.count(CampaignLead.id).label('leads_count')).outerjoin(CampaignLead).group_by(Campaign.id).all()
+    db.close()
+    return pd.DataFrame([(campaign.id, campaign.campaign_name, campaign.leads_count) for campaign in campaigns], columns=["ID", "Campaign Name", "Leads Count"])
+
+# Add a function to fetch leads for a specific campaign
+def fetch_leads_for_campaign(campaign_id):
+    campaign_id = validate_id(campaign_id, "campaign")
+    db = SessionLocal()
+    leads = db.query(Lead.id, Lead.email, Lead.first_name, Lead.last_name, Lead.company, Lead.job_title).join(CampaignLead).filter(CampaignLead.campaign_id == campaign_id).all()
+    db.close()
+    return pd.DataFrame([(lead.id, lead.email, lead.first_name, lead.last_name, lead.company, lead.job_title) for lead in leads], columns=["ID", "Email", "First Name", "Last Name", "Company", "Job Title"])
+
 # Gradio interface
 with gr.Blocks() as gradio_app:
-    gr.Markdown("# Email Campaign Management System")
+    gr.Markdown("# AUTOCLIENT")
 
     with gr.Tab("Projects and Campaigns"):
         with gr.Row():
@@ -562,28 +440,30 @@ with gr.Blocks() as gradio_app:
                 campaign_type = gr.Radio(["Email", "SMS"], label="Campaign Type")
                 create_campaign_btn = gr.Button("Create Campaign")
                 campaign_status = gr.Textbox(label="Campaign Status", interactive=False)
+        campaign_list = gr.Dataframe(fetch_campaigns_with_leads(), headers=["ID", "Campaign Name", "Leads Count"])
 
-    with gr.Tab("Message Templates"):
+    with gr.Tab("Email Templates"):
         with gr.Row():
-            with gr.Column():
-                template_name = gr.Textbox(label="Template Name")
-                subject = gr.Textbox(label="Subject")
-                body_content = gr.Code(language="html", label="Body Content")
-                campaign_id_for_template = gr.Dropdown(label="Campaign", choices=fetch_campaigns())
-                create_template_btn = gr.Button("Create Template")
-            with gr.Column():
-                template_status = gr.Textbox(label="Template Status", interactive=False)
-                template_preview = gr.HTML(label="Template Preview")
+            template_name = gr.Textbox(label="Template Name")
+            subject = gr.Textbox(label="Subject")
+        body_content = gr.Code(language="html", label="Body Content", lines=10)
+        campaign_id_for_template = gr.Dropdown(label="Campaign", choices=fetch_campaigns())
+        create_template_btn = gr.Button("Create Template")
+        template_status = gr.Textbox(label="Template Status", interactive=False)
+        template_preview = gr.HTML(label="Template Preview")
 
     with gr.Tab("Search Terms"):
         with gr.Row():
-            with gr.Column():
-                search_term = gr.Textbox(label="Search Term")
-                campaign_id_for_search = gr.Dropdown(label="Campaign", choices=fetch_campaigns())
-                add_term_btn = gr.Button("Add Search Term")
-            with gr.Column():
-                search_term_status = gr.Textbox(label="Search Term Status", interactive=False)
+            search_term = gr.Textbox(label="Search Term")
+            campaign_id_for_search = gr.Dropdown(label="Campaign", choices=fetch_campaigns())
+        add_term_btn = gr.Button("Add Search Term")
+        search_term_status = gr.Textbox(label="Search Term Status", interactive=False)
         search_term_list = gr.Dataframe(df_to_list(fetch_search_terms()), headers=["ID", "Search Term", "Leads Fetched", "Status"])
+        with gr.Row():
+            edit_term_id = gr.Number(label="Term ID to Edit")
+            new_term = gr.Textbox(label="New Term")
+        edit_term_btn = gr.Button("Edit Term")
+        delete_term_btn = gr.Button("Delete Term")
 
     with gr.Tab("Bulk Operations"):
         with gr.Row():
@@ -606,14 +486,82 @@ with gr.Blocks() as gradio_app:
             bulk_send_button = gr.Button("Bulk Send")
             bulk_search_send_button = gr.Button("Bulk Search & Send")
         
+        send_progress = gr.Progress()
         log_output = gr.TextArea(label="Process Logs", interactive=False)
 
     with gr.Tab("Manual Search"):
         with gr.Row():
             manual_search_term = gr.Textbox(label="Manual Search Term")
-            manual_num_results = gr.Slider(minimum=1, maximum=50, value=10, step=1)
-            manual_search_btn = gr.Button("Search")
-        manual_search_results = gr.Dataframe(headers=["Email", "Source"])
+            manual_num_results = gr.Slider(minimum=1, maximum=50, value=10, step=1, label="Number of Results")
+        manual_search_btn = gr.Button("Search")
+        manual_search_results = gr.Dataframe(headers=["Email", "Source", "First Name", "Last Name", "Company", "Job Title"])
+        add_to_campaign_btn = gr.Button("Add Selected to Campaign")
+        add_status = gr.Textbox(label="Add Status", interactive=False)
+
+    with gr.Tab("Leads"):
+        leads_df = gr.Dataframe(fetch_leads(), headers=["ID", "Email", "First Name", "Last Name", "Company", "Job Title"])
+        campaign_id_for_leads = gr.Dropdown(label="Campaign", choices=fetch_campaigns())
+        fetch_leads_btn = gr.Button("Fetch Leads for Campaign")
+        leads_for_campaign_df = gr.Dataframe(headers=["ID", "Email", "First Name", "Last Name", "Company", "Job Title"])
+        
+        with gr.Row():
+            lead_email = gr.Textbox(label="Email")
+            lead_first_name = gr.Textbox(label="First Name")
+            lead_last_name = gr.Textbox(label="Last Name")
+            lead_company = gr.Textbox(label="Company")
+            lead_job_title = gr.Textbox(label="Job Title")
+        add_lead_btn = gr.Button("Add Lead")
+        lead_status = gr.Textbox(label="Lead Status", interactive=False)
+
+    with gr.Tab("Campaign Analytics"):
+        campaign_select = gr.Dropdown(label="Select Campaign", choices=fetch_campaigns())
+        refresh_analytics_btn = gr.Button("Refresh Analytics")
+        with gr.Row():
+            total_leads = gr.Number(label="Total Leads")
+            emails_sent = gr.Number(label="Emails Sent")
+            open_rate = gr.Number(label="Open Rate")
+            click_rate = gr.Number(label="Click Rate")
+        performance_chart = gr.Plot(label="Campaign Performance")
+
+    with gr.Tab("Lead Import/Export"):
+        with gr.Row():
+            import_file = gr.File(label="Import CSV")
+            import_btn = gr.Button("Import Leads")
+        import_status = gr.Textbox(label="Import Status", interactive=False)
+        export_campaign = gr.Dropdown(label="Select Campaign for Export", choices=fetch_campaigns())
+        export_btn = gr.Button("Export Leads")
+        export_status = gr.Textbox(label="Export Status", interactive=False)
+
+    with gr.Tab("Email Scheduling"):
+        schedule_campaign = gr.Dropdown(label="Select Campaign", choices=fetch_campaigns())
+        schedule_template = gr.Dropdown(label="Select Template", choices=fetch_message_templates())
+        schedule_date = gr.Datetime(label="Schedule Date and Time")
+        schedule_btn = gr.Button("Schedule Campaign")
+        schedule_status = gr.Textbox(label="Schedule Status", interactive=False)
+        scheduled_campaigns = gr.Dataframe(headers=["ID", "Campaign", "Template", "Scheduled Time", "Status"])
+
+    with gr.Tab("AI Content Assistant"):
+        content_type = gr.Radio(["Email Subject", "Email Body", "Search Term"], label="Content Type")
+        campaign_context = gr.Dropdown(label="Select Campaign for Context", choices=fetch_campaigns())
+        prompt = gr.Textbox(label="Prompt for AI", lines=3)
+        generate_btn = gr.Button("Generate Content")
+        generated_content = gr.Textbox(label="Generated Content", lines=10)
+        use_content_btn = gr.Button("Use Generated Content")
+
+    with gr.Tab("User Management"):
+        with gr.Row():
+            username = gr.Textbox(label="Username")
+            email = gr.Textbox(label="Email")
+            password = gr.Textbox(label="Password", type="password")
+            role = gr.Dropdown(label="Role", choices=["Admin", "User", "Viewer"])
+        add_user_btn = gr.Button("Add User")
+        user_status = gr.Textbox(label="User Status", interactive=False)
+        user_list = gr.Dataframe(headers=["ID", "Username", "Email", "Role", "Last Login"])
+        with gr.Row():
+            edit_user_id = gr.Number(label="User ID to Edit")
+            new_role = gr.Dropdown(label="New Role", choices=["Admin", "User", "Viewer"])
+        edit_user_btn = gr.Button("Edit User Role")
+        delete_user_btn = gr.Button("Delete User")
 
     # Move these lines inside the Blocks context
     gradio_app.load(lambda: gr.update(value=df_to_list(fetch_search_terms())), outputs=search_term_df)
@@ -646,6 +594,7 @@ with gr.Blocks() as gradio_app:
     )
     manual_search_btn.click(manual_search, inputs=[manual_search_term, manual_num_results], outputs=manual_search_results)
     refresh_btn.click(refresh_search_terms, inputs=[campaign_id_for_bulk], outputs=[search_term_df])
+    fetch_leads_btn.click(fetch_leads_for_campaign, inputs=[campaign_id_for_leads], outputs=[leads_for_campaign_df])
 
 # Launch the app outside the Blocks context
 gradio_app.launch()