update

backend/app/auth_routes.py

@@ -81,11 +81,10 @@ async def firebase_login(
             db.refresh(user)
             print(f"[INFO] New user created via Firebase: {email}")
             
-            # Enrich contact data from Apollo.io and update Brevo + Monday.com
+            # Enrich contact data from Apollo.io and update Brevo
             try:
                 from .apollo_service import enrich_contact_by_email
                 from .brevo_service import create_brevo_contact, BREVO_TRIAL_LIST_ID
-                from .monday_service import create_monday_lead
                 
                 # Enrich contact data from Apollo.io
                 enriched_data = await enrich_contact_by_email(email)
@@ -121,20 +120,6 @@ async def firebase_login(
                     organization_address=enriched_data.get("organization_address") if enriched_data else None,
                     list_id=BREVO_TRIAL_LIST_ID
                 )
-                
-                # Create lead in Monday.com
-                await create_monday_lead(
-                    email=email,
-                    first_name=first_name,
-                    last_name=last_name,
-                    phone_number=enriched_data.get("phone_number") if enriched_data else None,
-                    linkedin_url=enriched_data.get("linkedin_url") if enriched_data else None,
-                    title=enriched_data.get("title") if enriched_data else None,
-                    headline=enriched_data.get("headline") if enriched_data else None,
-                    organization_name=org_name or (enriched_data.get("organization_name") if enriched_data else None),
-                    organization_website=enriched_data.get("organization_website") if enriched_data else None,
-                    organization_address=enriched_data.get("organization_address") if enriched_data else None,
-                )
             except Exception as e:
                 # Don't fail user creation if integrations fail
                 print(f"[WARNING] Failed to enrich/update contact for {email}: {str(e)}")

backend/app/monday_service.py

@@ -1,390 +0,0 @@
-"""
-Monday.com API service for creating leads with automatic field matching.
-Reference: https://developer.monday.com/api-reference/docs
-"""
-import os
-import httpx
-import json
-from typing import Optional, Dict, Any, List, Tuple
-from difflib import SequenceMatcher
-
-MONDAY_API_KEY = os.environ.get("MONDAY_API_KEY", "")
-MONDAY_API_URL = "https://api.monday.com/v2"
-MONDAY_BOARD_ID = os.environ.get("MONDAY_BOARD_ID", None)  # Your "New Leads" board ID
-
-# Cache for board columns to avoid repeated API calls
-_board_columns_cache: Dict[str, List[Dict[str, Any]]] = {}
-
-
-def _calculate_similarity(str1: str, str2: str) -> float:
-    """
-    Calculate similarity between two strings using SequenceMatcher.
-    Returns a value between 0.0 and 1.0.
-    """
-    return SequenceMatcher(None, str1.lower(), str2.lower()).ratio()
-
-
-def _find_best_column_match(
-    field_name: str,
-    available_columns: List[Dict[str, Any]],
-    min_similarity: float = 0.3
-) -> Optional[Tuple[str, str, float]]:
-    """
-    Find the best matching column for a field name using semantic similarity.
-    
-    Args:
-        field_name: The field name to match (e.g., "first_name", "email")
-        available_columns: List of column dicts with 'id' and 'title' keys
-        min_similarity: Minimum similarity threshold (0.0 to 1.0)
-        
-    Returns:
-        Tuple of (column_id, column_title, similarity_score) or None if no match found
-    """
-    best_match = None
-    best_score = 0.0
-    
-    # Normalize field name for matching
-    normalized_field = field_name.lower().replace("_", " ").replace("-", " ")
-    
-    # Common field name variations
-    field_variations = [
-        normalized_field,
-        field_name.lower(),
-        field_name.replace("_", ""),
-    ]
-    
-    # Add common synonyms
-    synonyms = {
-        "first_name": ["first name", "firstname", "fname", "given name"],
-        "last_name": ["last name", "lastname", "lname", "surname", "family name"],
-        "email": ["email address", "email", "e-mail", "mail"],
-        "phone_number": ["phone", "phone number", "telephone", "mobile", "cell"],
-        "linkedin_url": ["linkedin", "linkedin profile", "linkedin url", "linkedin link"],
-        "title": ["job title", "position", "role", "job"],
-        "headline": ["headline", "tagline", "bio"],
-        "organization_name": ["company", "organization", "org", "company name", "employer"],
-        "organization_website": ["website", "company website", "url", "web"],
-        "organization_address": ["address", "company address", "location"],
-    }
-    
-    if field_name in synonyms:
-        field_variations.extend(synonyms[field_name])
-    
-    for column in available_columns:
-        column_title = column.get("title", "").lower()
-        column_id = column.get("id", "")
-        
-        if not column_title or not column_id:
-            continue
-        
-        # Calculate similarity for each variation
-        for variation in field_variations:
-            score = _calculate_similarity(variation, column_title)
-            if score > best_score:
-                best_score = score
-                best_match = (column_id, column.get("title", ""), score)
-    
-    if best_match and best_score >= min_similarity:
-        return best_match
-    return None
-
-
-async def _get_board_columns(board_id: str) -> List[Dict[str, Any]]:
-    """
-    Fetch board columns from Monday.com API.
-    
-    Args:
-        board_id: Monday.com board ID
-        
-    Returns:
-        List of column dictionaries with 'id', 'title', and 'type' keys
-    """
-    # Check cache first
-    if board_id in _board_columns_cache:
-        return _board_columns_cache[board_id]
-    
-    if not MONDAY_API_KEY:
-        print("[WARNING] MONDAY_API_KEY not set, cannot fetch board columns")
-        return []
-    
-    query = """
-    query ($boardId: ID!) {
-        boards(ids: [$boardId]) {
-            columns {
-                id
-                title
-                type
-            }
-        }
-    }
-    """
-    
-    headers = {
-        "Authorization": MONDAY_API_KEY,
-        "Content-Type": "application/json"
-    }
-    
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(
-                MONDAY_API_URL,
-                json={
-                    "query": query,
-                    "variables": {"boardId": board_id}
-                },
-                headers=headers
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                if result.get("data") and result["data"].get("boards"):
-                    boards = result["data"]["boards"]
-                    if boards and boards[0].get("columns"):
-                        columns = boards[0]["columns"]
-                        # Cache the result
-                        _board_columns_cache[board_id] = columns
-                        print(f"[INFO] Fetched {len(columns)} columns from Monday.com board {board_id}")
-                        return columns
-                elif result.get("errors"):
-                    print(f"[ERROR] Failed to fetch board columns: {result['errors']}")
-            else:
-                print(f"[ERROR] Failed to fetch board columns: {response.status_code} - {response.text}")
-    except Exception as e:
-        print(f"[ERROR] Exception while fetching board columns: {str(e)}")
-    
-    return []
-
-
-def _format_column_value(value: Any, column_type: str, column_id: Optional[str] = None) -> Any:
-    """
-    Format a value according to Monday.com column type.
-    
-    Args:
-        value: The value to format
-        column_type: Monday.com column type (email, phone, link, text, etc.)
-        column_id: Column ID (for special handling)
-        
-    Returns:
-        For email/phone/link: Python dict object
-        For text/other types: Plain string
-    """
-    if value is None:
-        return ""
-    
-    value_str = str(value)
-    
-    if column_type == "email":
-        # Monday.com email format requires dict object (will be JSON encoded later)
-        return {"email": value_str, "text": value_str}
-    elif column_type == "phone":
-        return {"phone": value_str, "countryShortName": "US"}
-    elif column_type == "link":
-        # If it's already a URL, use it; otherwise create a link
-        if value_str.startswith("http://") or value_str.startswith("https://"):
-            return {"url": value_str, "text": value_str}
-        else:
-            return {"url": f"https://{value_str}", "text": value_str}
-    else:
-        # Text, status, and other types - just return the string
-        return value_str
-
-
-async def create_monday_lead(
-    email: str,
-    first_name: Optional[str] = None,
-    last_name: Optional[str] = None,
-    phone_number: Optional[str] = None,
-    linkedin_url: Optional[str] = None,
-    title: Optional[str] = None,
-    headline: Optional[str] = None,
-    organization_name: Optional[str] = None,
-    organization_website: Optional[str] = None,
-    organization_address: Optional[str] = None,
-    board_id: Optional[str] = None
-) -> bool:
-    """
-    Create a new lead item in Monday.com board.
-    
-    Args:
-        email: Contact email address (required)
-        first_name: Contact first name
-        last_name: Contact last name
-        phone_number: Phone number
-        linkedin_url: LinkedIn profile URL
-        title: Job title
-        headline: Professional headline
-        organization_name: Company name
-        organization_website: Company website
-        organization_address: Company address
-        board_id: Monday.com board ID as string (defaults to MONDAY_BOARD_ID env var)
-        
-    Returns:
-        True if lead created successfully, False otherwise
-    """
-    if not MONDAY_API_KEY:
-        print("[WARNING] MONDAY_API_KEY not set, skipping Monday.com lead creation")
-        return False
-    
-    target_board_id = board_id or MONDAY_BOARD_ID
-    if not target_board_id:
-        print("[WARNING] MONDAY_BOARD_ID not set, skipping Monday.com lead creation")
-        return False
-    
-    # Prepare item name (use full name or email)
-    item_name = email
-    if first_name and last_name:
-        item_name = f"{first_name} {last_name}"
-    elif first_name:
-        item_name = first_name
-    elif last_name:
-        item_name = last_name
-    
-    # Fetch board columns to automatically match fields
-    print(f"[INFO] Fetching Monday.com board columns for automatic field matching...")
-    board_columns = await _get_board_columns(str(target_board_id))
-    
-    if not board_columns:
-        print("[WARNING] Could not fetch board columns, skipping Monday.com lead creation")
-        return False
-    
-    # Create a mapping of column IDs to column types for formatting
-    column_types = {col["id"]: col.get("type", "text") for col in board_columns}
-    
-    # Prepare data fields to map
-    data_fields = {
-        "email": email,
-        "first_name": first_name,
-        "last_name": last_name,
-        "phone_number": phone_number,
-        "linkedin_url": linkedin_url,
-        "title": title,
-        "headline": headline,
-        "organization_name": organization_name,
-        "organization_website": organization_website,
-        "organization_address": organization_address,
-    }
-    
-    # Automatically match fields to columns using semantic similarity
-    column_values = {}
-    matched_fields = []
-    # Track which columns have been matched to handle duplicates (e.g., first_name and last_name -> Name)
-    column_matches = {}  # column_id -> (field_name, value)
-    
-    for field_name, field_value in data_fields.items():
-        if not field_value:
-            continue
-        
-        match = _find_best_column_match(field_name, board_columns)
-        if match:
-            column_id, column_title, similarity = match
-            column_type = column_types.get(column_id, "text")
-            
-            # Handle special case: if first_name and last_name both match to the same "Name" column
-            if column_id in column_matches:
-                existing_field, existing_value = column_matches[column_id]
-                # If both first_name and last_name match to the same column, combine them
-                if (field_name in ["first_name", "last_name"] and 
-                    existing_field in ["first_name", "last_name"] and
-                    field_name != existing_field):
-                    # Combine first and last name
-                    if field_name == "first_name":
-                        combined_value = f"{field_value} {existing_value}"
-                    else:
-                        combined_value = f"{existing_value} {field_value}"
-                    formatted_value = _format_column_value(combined_value, column_type, column_id)
-                    column_values[column_id] = formatted_value
-                    matched_fields.append(f"{existing_field}+{field_name} -> {column_title} (combined)")
-                    print(f"[INFO] Combined '{existing_field}' and '{field_name}' to column '{column_title}' (ID: {column_id})")
-                    continue
-                else:
-                    # Different fields matching to same column - use the one with higher similarity
-                    print(f"[DEBUG] Column '{column_title}' already matched to '{existing_field}', skipping '{field_name}'")
-                    continue
-            
-            formatted_value = _format_column_value(field_value, column_type, column_id)
-            column_values[column_id] = formatted_value
-            column_matches[column_id] = (field_name, field_value)
-            matched_fields.append(f"{field_name} -> {column_title} (similarity: {similarity:.2f})")
-            print(f"[INFO] Matched '{field_name}' to column '{column_title}' (ID: {column_id}, type: {column_type}, value: {formatted_value[:100] if len(str(formatted_value)) > 100 else formatted_value})")
-        else:
-            print(f"[DEBUG] No suitable column match found for '{field_name}' (skipping)")
-    
-    if not column_values:
-        print("[WARNING] No fields could be matched to board columns")
-        return False
-    
-    print(f"[INFO] Successfully matched {len(matched_fields)} fields to Monday.com columns")
-    
-    # Convert column_values to JSON string for GraphQL mutation
-    # Monday.com expects column values as a JSON string where:
-    # - Text columns: plain string values
-    # - Email/Phone/Link columns: dict objects (properly JSON encoded)
-    column_values_json = json.dumps(column_values)
-    print(f"[DEBUG] Monday.com column_values JSON: {column_values_json[:500]}")
-    
-    # GraphQL mutation
-    # Note: Monday.com uses ID! (string) type for board_id, not Int!
-    mutation = """
-    mutation ($boardId: ID!, $itemName: String!, $columnValues: JSON!) {
-        create_item (board_id: $boardId, item_name: $itemName, column_values: $columnValues) {
-            id
-        }
-    }
-    """
-    
-    # Convert board_id to string (Monday.com expects ID! which is a string)
-    board_id_str = str(target_board_id)
-    
-    variables = {
-        "boardId": board_id_str,
-        "itemName": item_name,
-        "columnValues": column_values_json
-    }
-    
-    headers = {
-        "Authorization": MONDAY_API_KEY,
-        "Content-Type": "application/json"
-    }
-    
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.post(
-                MONDAY_API_URL,
-                json={
-                    "query": mutation,
-                    "variables": variables
-                },
-                headers=headers
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                if result.get("data") and result["data"].get("create_item"):
-                    item_id = result["data"]["create_item"].get("id")
-                    print(f"[INFO] Successfully created Monday.com lead: {item_name} (ID: {item_id})")
-                    return True
-                elif result.get("errors"):
-                    errors = result.get("errors", [])
-                    for error in errors:
-                        error_msg = error.get("message", "Unknown error")
-                        error_path = error.get("path", [])
-                        print(f"[ERROR] Monday.com API error: {error_msg}")
-                        if error_path:
-                            print(f"[ERROR] Error path: {error_path}")
-                    # Log full error for debugging
-                    print(f"[DEBUG] Full Monday.com error response: {json.dumps(errors, indent=2)}")
-                    return False
-                else:
-                    print(f"[ERROR] Unexpected Monday.com API response: {result}")
-                    return False
-            else:
-                error_data = response.text
-                print(f"[ERROR] Failed to create Monday.com lead: {response.status_code} - {error_data}")
-                return False
-                
-    except httpx.HTTPStatusError as e:
-        print(f"[ERROR] Monday.com API HTTP error: {e.response.status_code} - {e.response.text}")
-        return False
-    except Exception as e:
-        print(f"[ERROR] Failed to create Monday.com lead: {str(e)}")
-        return False

backend/app/otp_service.py

@@ -133,11 +133,10 @@ async def verify_otp(email: str, otp: str, db: Session) -> User:
         db.refresh(user)
         print(f"[INFO] New user created via OTP: {email_lower}")
         
-        # Enrich contact data from Apollo.io and update Brevo + Monday.com
+        # Enrich contact data from Apollo.io and update Brevo
         try:
             from .apollo_service import enrich_contact_by_email
             from .brevo_service import create_brevo_contact, BREVO_TRIAL_LIST_ID
-            from .monday_service import create_monday_lead
             
             # Enrich contact data from Apollo.io
             enriched_data = await enrich_contact_by_email(email_lower)
@@ -166,20 +165,6 @@ async def verify_otp(email: str, otp: str, db: Session) -> User:
                 organization_address=enriched_data.get("organization_address") if enriched_data else None,
                 list_id=BREVO_TRIAL_LIST_ID
             )
-            
-            # Create lead in Monday.com
-            await create_monday_lead(
-                email=email_lower,
-                first_name=first_name,
-                last_name=last_name,
-                phone_number=enriched_data.get("phone_number") if enriched_data else None,
-                linkedin_url=enriched_data.get("linkedin_url") if enriched_data else None,
-                title=enriched_data.get("title") if enriched_data else None,
-                headline=enriched_data.get("headline") if enriched_data else None,
-                organization_name=org_name or (enriched_data.get("organization_name") if enriched_data else None),
-                organization_website=enriched_data.get("organization_website") if enriched_data else None,
-                organization_address=enriched_data.get("organization_address") if enriched_data else None,
-            )
         except Exception as e:
             # Don't fail user creation if integrations fail
             print(f"[WARNING] Failed to enrich/update contact for {email_lower}: {str(e)}")