diff --git a/Backend/.env-example b/Backend/.env-example index 18e42cd..3d7415e 100644 --- a/Backend/.env-example +++ b/Backend/.env-example @@ -3,8 +3,13 @@ password=[YOUR-PASSWORD] host= port=5432 dbname=postgres -GROQ_API_KEY= +GROQ_API_KEY=your_groq_api_key_here SUPABASE_URL= SUPABASE_KEY= GEMINI_API_KEY= -YOUTUBE_API_KEY= \ No newline at end of file +YOUTUBE_API_KEY= + +# Redis Cloud configuration +REDIS_HOST=your-redis-cloud-host +REDIS_PORT=12345 +REDIS_PASSWORD=your-redis-cloud-password \ No newline at end of file diff --git a/Backend/app/main.py b/Backend/app/main.py index 86d892a..8739c83 100644 --- a/Backend/app/main.py +++ b/Backend/app/main.py @@ -6,6 +6,12 @@ from .routes.post import router as post_router from .routes.chat import router as chat_router from .routes.match import router as match_router +from .routes.brand_dashboard import router as brand_dashboard_router +from .routes.ai_query import router as ai_query_router +from .routes.contracts import router as contracts_router +from .routes.contracts_ai import router as contracts_ai_router +from .routes.contracts_generation import router as contracts_generation_router +from .routes.pricing import router as pricing_router from sqlalchemy.exc import SQLAlchemyError import logging import os @@ -54,6 +60,12 @@ async def lifespan(app: FastAPI): app.include_router(post_router) app.include_router(chat_router) app.include_router(match_router) +app.include_router(brand_dashboard_router) +app.include_router(ai_query_router) +app.include_router(contracts_router) +app.include_router(contracts_ai_router) +app.include_router(contracts_generation_router) +app.include_router(pricing_router) app.include_router(ai.router) app.include_router(ai.youtube_router) diff --git a/Backend/app/models/models.py b/Backend/app/models/models.py index 56681ab..a521269 100644 --- a/Backend/app/models/models.py +++ b/Backend/app/models/models.py @@ -12,7 +12,7 @@ TIMESTAMP, ) from sqlalchemy.orm import relationship -from datetime import datetime +from datetime import datetime, timezone from app.db.db import Base import uuid @@ -160,3 +160,82 @@ class SponsorshipPayment(Base): brand = relationship( "User", foreign_keys=[brand_id], back_populates="brand_payments" ) + + +# ============================================================================ +# BRAND DASHBOARD MODELS +# ============================================================================ + +# Brand Profile Table (Extended brand information) +class BrandProfile(Base): + __tablename__ = "brand_profiles" + + id = Column(String, primary_key=True, default=generate_uuid) + user_id = Column(String, ForeignKey("users.id"), nullable=False) + company_name = Column(String, nullable=True) + website = Column(String, nullable=True) + industry = Column(String, nullable=True) + contact_person = Column(String, nullable=True) + contact_email = Column(String, nullable=True) + created_at = Column( + DateTime(timezone=True), default=lambda: datetime.now(timezone.utc) + ) + + # Relationships + user = relationship("User", backref="brand_profile") + + +# Campaign Metrics Table (Performance tracking) +class CampaignMetrics(Base): + __tablename__ = "campaign_metrics" + + id = Column(String, primary_key=True, default=generate_uuid) + campaign_id = Column(String, ForeignKey("sponsorships.id"), nullable=False) + impressions = Column(Integer, nullable=True) + clicks = Column(Integer, nullable=True) + conversions = Column(Integer, nullable=True) + revenue = Column(DECIMAL(10, 2), nullable=True) + engagement_rate = Column(Float, nullable=True) + recorded_at = Column( + DateTime(timezone=True), default=lambda: datetime.now(timezone.utc) + ) + + # Relationships + campaign = relationship("Sponsorship", backref="metrics") + + +# Contracts Table (Contract management) +class Contract(Base): + __tablename__ = "contracts" + + id = Column(String, primary_key=True, default=generate_uuid) + sponsorship_id = Column(String, ForeignKey("sponsorships.id"), nullable=False) + creator_id = Column(String, ForeignKey("users.id"), nullable=False) + brand_id = Column(String, ForeignKey("users.id"), nullable=False) + contract_url = Column(String, nullable=True) + status = Column(String, default="draft") # draft, signed, completed, cancelled + created_at = Column( + DateTime(timezone=True), default=lambda: datetime.now(timezone.utc) + ) + + # Relationships + sponsorship = relationship("Sponsorship", backref="contracts") + creator = relationship("User", foreign_keys=[creator_id], backref="creator_contracts") + brand = relationship("User", foreign_keys=[brand_id], backref="brand_contracts") + + +# Creator Matches Table (AI-powered matching) +class CreatorMatch(Base): + __tablename__ = "creator_matches" + + id = Column(String, primary_key=True, default=generate_uuid) + brand_id = Column(String, ForeignKey("users.id"), nullable=False) + creator_id = Column(String, ForeignKey("users.id"), nullable=False) + match_score = Column(Float, nullable=True) + matched_at = Column( + DateTime(timezone=True), default=lambda: datetime.now(timezone.utc) + ) + + # Relationships + brand = relationship("User", foreign_keys=[brand_id], backref="creator_matches") + creator = relationship("User", foreign_keys=[creator_id], backref="brand_matches") diff --git a/Backend/app/routes/ai_query.py b/Backend/app/routes/ai_query.py new file mode 100644 index 0000000..6022305 --- /dev/null +++ b/Backend/app/routes/ai_query.py @@ -0,0 +1,244 @@ +from fastapi import APIRouter, HTTPException, Query, Depends, Request +from typing import Dict, Any, Optional +from pydantic import BaseModel +import logging +from ..services.ai_router import ai_router +from ..services.redis_client import get_session_state, save_session_state +import uuid + +# Setup logging +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +# Define Router +router = APIRouter(prefix="/api/ai", tags=["AI Query"]) + +# Pydantic models for request/response +class AIQueryRequest(BaseModel): + query: str + brand_id: Optional[str] = None + context: Optional[Dict[str, Any]] = None + +class AIQueryResponse(BaseModel): + intent: str + route: Optional[str] = None + parameters: Dict[str, Any] = {} + follow_up_needed: bool = False + follow_up_question: Optional[str] = None + explanation: str + original_query: str + timestamp: str + +@router.post("/query", response_model=AIQueryResponse) +async def process_ai_query(request: AIQueryRequest, http_request: Request): + """ + Process a natural language query through AI and return routing information + """ + try: + # Validate input + if not request.query or len(request.query.strip()) == 0: + raise HTTPException(status_code=400, detail="Query cannot be empty") + + # Process query through AI router + result = await ai_router.process_query( + query=request.query.strip(), + brand_id=request.brand_id + ) + + # --- Hybrid Orchestration Logic --- + # Extended intent-to-parameter mapping for all available routes + intent_param_map = { + "dashboard_overview": {"required": ["brand_id"], "optional": []}, + "brand_profile": {"required": ["user_id"], "optional": []}, + "campaigns": {"required": ["brand_id"], "optional": ["campaign_id"]}, + "creator_matches": {"required": ["brand_id"], "optional": []}, + "creator_search": {"required": ["brand_id"], "optional": ["industry", "min_engagement", "location"]}, + "creator_profile": {"required": ["creator_id", "brand_id"], "optional": []}, + "analytics_performance": {"required": ["brand_id"], "optional": []}, + "analytics_revenue": {"required": ["brand_id"], "optional": []}, + "contracts": {"required": ["brand_id"], "optional": ["contract_id"]}, + } + intent = result.get("route") + params = result.get("parameters", {}) + + # Debug: Log the parameters to understand the type issue + logger.info(f"Intent: {intent}") + logger.info(f"Params: {params}") + logger.info(f"Params type: {type(params)}") + for key, value in params.items(): + logger.info(f" {key}: {value} (type: {type(value)})") + + api_result = None + api_error = None + # Prepare arguments for API calls, including optional params if present + def get_api_args(intent, params): + args = {} + if intent in intent_param_map: + # Add required params + for param in intent_param_map[intent]["required"]: + if params.get(param) is not None: + args[param] = params[param] + # Add optional params if present + for param in intent_param_map[intent]["optional"]: + if params.get(param) is not None: + args[param] = params[param] + return args + + # Check if all required params are present + all_params_present = True + missing_params = [] + if intent in intent_param_map: + for param in intent_param_map[intent]["required"]: + if not params.get(param): + all_params_present = False + missing_params.append(param) + + # Allow queries with only optional params if API supports it (e.g., creator_search with filters) + only_optional_params = False + if intent in intent_param_map and not all_params_present: + # If at least one optional param is present and no required params are present + if ( + len(intent_param_map[intent]["optional"]) > 0 and + all(params.get(p) is None for p in intent_param_map[intent]["required"]) and + any(params.get(p) is not None for p in intent_param_map[intent]["optional"]) + ): + only_optional_params = True + + if (intent and all_params_present) or (intent and only_optional_params): + try: + api_args = get_api_args(intent, params) + # Use aliases for get_campaigns and get_contracts + if intent == "creator_search": + from ..routes.brand_dashboard import search_creators + api_result = await search_creators(**api_args) + elif intent == "dashboard_overview": + from ..routes.brand_dashboard import get_dashboard_overview + api_result = await get_dashboard_overview(**api_args) + elif intent == "creator_matches": + from ..routes.brand_dashboard import get_creator_matches + api_result = await get_creator_matches(**api_args) + elif intent == "brand_profile": + from ..routes.brand_dashboard import get_brand_profile + api_result = await get_brand_profile(**api_args) + elif intent == "campaigns": + from ..routes.brand_dashboard import get_brand_campaigns as get_campaigns + api_result = await get_campaigns(**api_args) + elif intent == "creator_profile": + from ..routes.brand_dashboard import get_creator_profile + api_result = await get_creator_profile(**api_args) + elif intent == "analytics_performance": + from ..routes.brand_dashboard import get_campaign_performance + api_result = await get_campaign_performance(**api_args) + elif intent == "analytics_revenue": + from ..routes.brand_dashboard import get_revenue_analytics + api_result = await get_revenue_analytics(**api_args) + elif intent == "contracts": + from ..routes.brand_dashboard import get_brand_contracts as get_contracts + api_result = await get_contracts(**api_args) + except Exception as api_exc: + logger.error(f"API call failed for intent '{intent}': {api_exc}") + api_error = str(api_exc) + + # Convert to response model, add 'result' field for actual data + response = AIQueryResponse( + intent=result.get("intent", "unknown"), + route=result.get("route"), + parameters=params, + follow_up_needed=not all_params_present and not only_optional_params or api_error is not None, + follow_up_question=(result.get("follow_up_question") if not all_params_present and not only_optional_params else None), + explanation=(result.get("explanation", "") if not api_error else f"An error occurred while processing your request: {api_error}"), + original_query=result.get("original_query", request.query), + timestamp=result.get("timestamp", ""), + ) + # Attach result if available + response_dict = response.dict() + # 1. Get or generate session_id + session_id = http_request.headers.get("X-Session-ID") + if not session_id and request.context: + session_id = request.context.get("session_id") + if not session_id: + session_id = str(uuid.uuid4()) + + # 2. Load previous state from Redis + state = await get_session_state(session_id) + prev_params = state.get("params", {}) + prev_intent = state.get("intent") + + # 3. Merge new params and intent + # Use new intent if present, else previous + intent = result.get("route") or prev_intent + params = {**prev_params, **result.get("parameters", {})} + state["params"] = params + state["intent"] = intent + + # 4. Save updated state to Redis + await save_session_state(session_id, state) + + response_dict["session_id"] = session_id + if api_result is not None: + response_dict["result"] = api_result + if api_error is not None: + response_dict["error"] = api_error + return response_dict + except HTTPException: + raise + except Exception as e: + logger.error(f"Error processing AI query: {e}") + raise HTTPException(status_code=500, detail="Failed to process AI query") + +@router.get("/routes") +async def get_available_routes(): + """ + Get list of available routes that the AI can route to + """ + try: + routes = ai_router.list_available_routes() + return { + "available_routes": routes, + "total_routes": len(routes) + } + except Exception as e: + logger.error(f"Error fetching available routes: {e}") + raise HTTPException(status_code=500, detail="Failed to fetch routes") + +@router.get("/route/{route_name}") +async def get_route_info(route_name: str): + """ + Get detailed information about a specific route + """ + try: + route_info = ai_router.get_route_info(route_name) + if not route_info: + raise HTTPException(status_code=404, detail=f"Route '{route_name}' not found") + + return { + "route_name": route_name, + "info": route_info + } + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching route info: {e}") + raise HTTPException(status_code=500, detail="Failed to fetch route info") + +@router.post("/test") +async def test_ai_query(query: str = Query(..., description="Test query")): + """ + Test endpoint for AI query processing (for development) + """ + try: + # Process test query + result = await ai_router.process_query(query=query) + + return { + "test_query": query, + "result": result, + "status": "success" + } + except Exception as e: + logger.error(f"Error in test AI query: {e}") + return { + "test_query": query, + "error": str(e), + "status": "error" + } \ No newline at end of file diff --git a/Backend/app/routes/brand_dashboard.py b/Backend/app/routes/brand_dashboard.py new file mode 100644 index 0000000..2c632a8 --- /dev/null +++ b/Backend/app/routes/brand_dashboard.py @@ -0,0 +1,1629 @@ +from fastapi import APIRouter, HTTPException, Depends, Query +from typing import List, Optional +from sqlalchemy.ext.asyncio import AsyncSession +from sqlalchemy.future import select +from ..db.db import AsyncSessionLocal +from ..models.models import ( + User, Sponsorship, BrandProfile, CampaignMetrics, + Contract, CreatorMatch, SponsorshipApplication +) +from ..schemas.schema import ( + BrandProfileCreate, BrandProfileUpdate, BrandProfileResponse, + CampaignMetricsCreate, CampaignMetricsResponse, + ContractCreate, ContractUpdate, ContractResponse, + CreatorMatchResponse, DashboardOverviewResponse, + CampaignAnalyticsResponse, CreatorMatchAnalyticsResponse, + SponsorshipApplicationResponse, ApplicationUpdateRequest, ApplicationSummaryResponse, + PaymentResponse, PaymentStatusUpdate, PaymentAnalyticsResponse, + CampaignMetricsUpdate, SponsorshipCreate +) + +import os +from supabase import create_client, Client +from dotenv import load_dotenv +import uuid +from datetime import datetime, timezone +import logging + +# Load environment variables +load_dotenv() +url: str = os.getenv("SUPABASE_URL") +key: str = os.getenv("SUPABASE_KEY") +if not url or not key: + raise ValueError("SUPABASE_URL and SUPABASE_KEY must be set in environment variables") +supabase: Client = create_client(url, key) + +# Setup logging +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +# Define Router +router = APIRouter(prefix="/api/brand", tags=["Brand Dashboard"]) + +# Helper Functions +def generate_uuid(): + return str(uuid.uuid4()) + +def current_timestamp(): + return datetime.now(timezone.utc).isoformat() + +# Security Helper Functions +def validate_brand_access(brand_id: str, current_user_id: str): + """Validate that the current user can access the brand data""" + if brand_id != current_user_id: + raise HTTPException(status_code=403, detail="Access denied: You can only access your own data") + return True + +def require_brand_role(user_role: str): + """Ensure user has brand role""" + if user_role != "brand": + raise HTTPException(status_code=403, detail="Access denied: Brand role required") + return True + +def validate_uuid_format(id_value: str, field_name: str = "ID"): + """Validate UUID format""" + if not id_value or len(id_value) != 36: + raise HTTPException(status_code=400, detail=f"Invalid {field_name} format") + return True + +def safe_supabase_query(query_func, error_message: str = "Database operation failed"): + """Safely execute Supabase queries with proper error handling""" + try: + result = query_func() + return result.data if result.data else [] + except Exception as e: + logger.error(f"Supabase error in {error_message}: {e}") + raise HTTPException(status_code=500, detail=error_message) + +# Simple in-memory rate limiting (for development) +request_counts = {} + +def check_rate_limit(user_id: str, max_requests: int = 100, window_seconds: int = 60): + """Simple rate limiting check (in production, use Redis)""" + current_time = datetime.now(timezone.utc) + key = f"{user_id}:{current_time.minute}" + + if key not in request_counts: + request_counts[key] = 0 + + request_counts[key] += 1 + + if request_counts[key] > max_requests: + raise HTTPException(status_code=429, detail="Rate limit exceeded") + + return True + +# ============================================================================ +# DASHBOARD OVERVIEW ROUTES +# ============================================================================ + +@router.get("/dashboard/overview", response_model=DashboardOverviewResponse) +async def get_dashboard_overview(brand_id: str = Query(..., description="Brand user ID")): + """ + Get dashboard overview with key metrics for a brand + """ + # Validate brand_id format + validate_uuid_format(brand_id, "brand_id") + + try: + # Get brand's campaigns + campaigns = safe_supabase_query( + lambda: supabase.table("sponsorships").select("*").eq("brand_id", brand_id).execute(), + "Failed to fetch campaigns" + ) + + # Get brand's profile + profile_result = supabase.table("brand_profiles").select("*").eq("user_id", brand_id).execute() + profile = profile_result.data[0] if profile_result.data else None + + # Get recent applications (only if campaigns exist) + applications = [] + if campaigns: + campaign_ids = [campaign["id"] for campaign in campaigns] + applications = safe_supabase_query( + lambda: supabase.table("sponsorship_applications").select("*").in_("sponsorship_id", campaign_ids).execute(), + "Failed to fetch applications" + ) + + # Calculate metrics + total_campaigns = len(campaigns) + active_campaigns = len([c for c in campaigns if c.get("status") == "open"]) + + # Calculate total revenue from completed payments + payments = safe_supabase_query( + lambda: supabase.table("sponsorship_payments").select("*").eq("brand_id", brand_id).eq("status", "completed").execute(), + "Failed to fetch payments" + ) + total_revenue = sum(float(payment.get("amount", 0)) for payment in payments) + + # Get creator matches + matches = safe_supabase_query( + lambda: supabase.table("creator_matches").select("*").eq("brand_id", brand_id).execute(), + "Failed to fetch creator matches" + ) + total_creators_matched = len(matches) + + # Recent activity (last 5 applications) + recent_activity = applications[:5] if applications else [] + + return DashboardOverviewResponse( + total_campaigns=total_campaigns, + active_campaigns=active_campaigns, + total_revenue=total_revenue, + total_creators_matched=total_creators_matched, + recent_activity=recent_activity + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Unexpected error in dashboard overview: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/dashboard/kpis") +async def get_dashboard_kpis(brand_id: str = Query(..., description="Brand user ID")): + """ + Get comprehensive KPI data for brand dashboard + """ + # Validate brand_id format + validate_uuid_format(brand_id, "brand_id") + + try: + # Get brand's campaigns + campaigns = safe_supabase_query( + lambda: supabase.table("sponsorships").select("*").eq("brand_id", brand_id).execute(), + "Failed to fetch campaigns" + ) + + # Calculate campaign metrics + total_campaigns = len(campaigns) + active_campaigns = len([c for c in campaigns if c.get("status") == "open"]) + + # Get campaign metrics for engagement and reach calculations + campaign_metrics = [] + total_reach = 0 + total_engagement = 0 + total_impressions = 0 + + if campaigns: + campaign_ids = [campaign["id"] for campaign in campaigns] + campaign_metrics = safe_supabase_query( + lambda: supabase.table("campaign_metrics").select("*").in_("campaign_id", campaign_ids).execute(), + "Failed to fetch campaign metrics" + ) + + # Calculate total reach and engagement + for metric in campaign_metrics: + total_impressions += metric.get("impressions", 0) + total_engagement += metric.get("engagement_rate", 0) * metric.get("impressions", 0) + + # Calculate average engagement rate (cap at 100%) + avg_engagement_rate = min((total_engagement / total_impressions * 100) if total_impressions > 0 else 0, 100) + + # Get payment data for financial metrics + all_payments = safe_supabase_query( + lambda: supabase.table("sponsorship_payments").select("*").eq("brand_id", brand_id).execute(), + "Failed to fetch payments" + ) + + completed_payments = [p for p in all_payments if p.get("status") == "completed"] + pending_payments = [p for p in all_payments if p.get("status") == "pending"] + + # Calculate financial metrics + total_spent = sum(float(payment.get("amount", 0)) for payment in completed_payments) + pending_amount = sum(float(payment.get("amount", 0)) for payment in pending_payments) + + # Calculate ROI (assuming revenue is tracked in campaign_metrics) + total_revenue = sum(float(metric.get("revenue", 0)) for metric in campaign_metrics) + roi_percentage = ((total_revenue - total_spent) / total_spent * 100) if total_spent > 0 else 0 + + # Calculate cost per engagement + total_engagements = sum(metric.get("clicks", 0) for metric in campaign_metrics) + cost_per_engagement = (total_spent / total_engagements) if total_engagements > 0 else 0 + + # Get creator matches for creator metrics + creator_matches = safe_supabase_query( + lambda: supabase.table("creator_matches").select("*").eq("brand_id", brand_id).execute(), + "Failed to fetch creator matches" + ) + + # Get applications for activity metrics + applications = [] + if campaigns: + campaign_ids = [campaign["id"] for campaign in campaigns] + applications = safe_supabase_query( + lambda: supabase.table("sponsorship_applications").select("*").in_("sponsorship_id", campaign_ids).execute(), + "Failed to fetch applications" + ) + + pending_applications = len([app for app in applications if app.get("status") == "pending"]) + + # Format reach for display (convert to K/M format) + def format_reach(number): + if number >= 1000000: + return f"{number/1000000:.1f}M" + elif number >= 1000: + return f"{number/1000:.1f}K" + else: + return str(number) + + return { + "kpis": { + "activeCampaigns": active_campaigns, + "totalReach": format_reach(total_impressions), + "engagementRate": round(avg_engagement_rate, 1), + "roi": round(roi_percentage, 1), + "budgetSpent": total_spent, + "budgetAllocated": total_spent + pending_amount, + "costPerEngagement": round(cost_per_engagement, 2) + }, + "creators": { + "totalConnected": len(creator_matches), + "pendingApplications": pending_applications, + "topPerformers": len([m for m in creator_matches if m.get("match_score", 0) > 0.8]), + "newRecommendations": len([m for m in creator_matches if m.get("match_score", 0) > 0.9]) + }, + "financial": { + "monthlySpend": total_spent, + "pendingPayments": pending_amount, + "costPerEngagement": cost_per_engagement, + "budgetUtilization": round((total_spent / (total_spent + pending_amount)) * 100, 1) if (total_spent + pending_amount) > 0 else 0 + }, + "analytics": { + "audienceGrowth": 12.5, # Will be replaced by real analytics endpoint + "bestContentType": "Video", # Will be replaced by real analytics endpoint + "topGeographicMarket": "United States", # Will be replaced by real analytics endpoint + "trendingTopics": ["Sustainability", "Tech Reviews", "Fitness"] # Will be replaced by real analytics endpoint + } + } + + except HTTPException: + raise + except Exception as e: + logger.error(f"Unexpected error in dashboard KPIs: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/dashboard/campaigns/overview") +async def get_campaigns_overview(brand_id: str = Query(..., description="Brand user ID")): + """ + Get campaigns overview for dashboard + """ + # Validate brand_id format + validate_uuid_format(brand_id, "brand_id") + + try: + # Get brand's campaigns + campaigns = safe_supabase_query( + lambda: supabase.table("sponsorships").select("*").eq("brand_id", brand_id).execute(), + "Failed to fetch campaigns" + ) + + # Get campaign metrics for each campaign + campaigns_with_metrics = [] + + for campaign in campaigns: + campaign_metrics = safe_supabase_query( + lambda: supabase.table("campaign_metrics").select("*").eq("campaign_id", campaign["id"]).execute(), + f"Failed to fetch metrics for campaign {campaign['id']}" + ) + + # Get latest metrics for this campaign + latest_metrics = campaign_metrics[-1] if campaign_metrics else {} + + # Calculate performance rating + engagement_rate = latest_metrics.get("engagement_rate", 0) + if engagement_rate >= 5.0: + performance = "excellent" + elif engagement_rate >= 4.0: + performance = "good" + elif engagement_rate >= 3.0: + performance = "average" + else: + performance = "poor" + + # Format reach + impressions = latest_metrics.get("impressions", 0) + if impressions >= 1000000: + reach = f"{impressions/1000000:.1f}M" + elif impressions >= 1000: + reach = f"{impressions/1000:.1f}K" + else: + reach = str(impressions) + + campaigns_with_metrics.append({ + "id": campaign["id"], + "name": campaign["title"], + "status": campaign.get("status", "draft"), + "performance": performance, + "reach": reach, + "engagement": round(engagement_rate, 1), + "deadline": campaign.get("deadline", campaign.get("created_at", "")), + "budget": campaign.get("budget", 0) + }) + + # Sort by recent campaigns first + campaigns_with_metrics.sort(key=lambda x: x["deadline"], reverse=True) + + return { + "campaigns": campaigns_with_metrics[:5] # Return top 5 recent campaigns + } + + except HTTPException: + raise + except Exception as e: + logger.error(f"Unexpected error in campaigns overview: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/dashboard/notifications") +async def get_dashboard_notifications(brand_id: str = Query(..., description="Brand user ID")): + """ + Get notifications for brand dashboard + """ + # Validate brand_id format + validate_uuid_format(brand_id, "brand_id") + + try: + notifications = [] + + # Get pending applications + applications = safe_supabase_query( + lambda: supabase.table("sponsorship_applications").select("*").eq("status", "pending").execute(), + "Failed to fetch applications" + ) + + # Filter applications for this brand's campaigns + brand_campaigns = safe_supabase_query( + lambda: supabase.table("sponsorships").select("id").eq("brand_id", brand_id).execute(), + "Failed to fetch brand campaigns" + ) + + brand_campaign_ids = [campaign["id"] for campaign in brand_campaigns] + pending_applications = [app for app in applications if app.get("sponsorship_id") in brand_campaign_ids] + + if pending_applications: + notifications.append({ + "id": "1", + "type": "urgent", + "message": f"{len(pending_applications)} applications need review", + "time": "2 hours ago" + }) + + # Check for underperforming campaigns + campaigns = safe_supabase_query( + lambda: supabase.table("sponsorships").select("*").eq("brand_id", brand_id).eq("status", "open").execute(), + "Failed to fetch campaigns" + ) + + for campaign in campaigns: + campaign_metrics = safe_supabase_query( + lambda: supabase.table("campaign_metrics").select("*").eq("campaign_id", campaign["id"]).execute(), + f"Failed to fetch metrics for campaign {campaign['id']}" + ) + + if campaign_metrics: + latest_metrics = campaign_metrics[-1] + engagement_rate = latest_metrics.get("engagement_rate", 0) + + if engagement_rate < 3.0: # Underperforming threshold + notifications.append({ + "id": f"campaign_{campaign['id']}", + "type": "alert", + "message": f"Campaign '{campaign['title']}' underperforming", + "time": "4 hours ago" + }) + + # Check for new creator recommendations + creator_matches = safe_supabase_query( + lambda: supabase.table("creator_matches").select("*").eq("brand_id", brand_id).execute(), + "Failed to fetch creator matches" + ) + + high_score_matches = [m for m in creator_matches if m.get("match_score", 0) > 0.9] + + if high_score_matches: + notifications.append({ + "id": "3", + "type": "info", + "message": "New creator recommendations available", + "time": "1 day ago" + }) + + # Add some mock notifications for demonstration + if not notifications: + notifications = [ + { + "id": "1", + "type": "urgent", + "message": "3 applications need review", + "time": "2 hours ago" + }, + { + "id": "2", + "type": "alert", + "message": "Campaign 'Tech Review' underperforming", + "time": "4 hours ago" + }, + { + "id": "3", + "type": "info", + "message": "New creator recommendations available", + "time": "1 day ago" + } + ] + + return { + "notifications": notifications + } + + except HTTPException: + raise + except Exception as e: + logger.error(f"Unexpected error in notifications: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/dashboard/timeline") +async def get_dashboard_timeline(brand_id: str = Query(..., description="Brand user ID")): + """ + Get timeline data for dashboard + """ + # Validate brand_id format + validate_uuid_format(brand_id, "brand_id") + + try: + timeline_items = [] + + # Get campaigns with deadlines + campaigns = safe_supabase_query( + lambda: supabase.table("sponsorships").select("*").eq("brand_id", brand_id).eq("status", "open").execute(), + "Failed to fetch campaigns" + ) + + for campaign in campaigns: + if campaign.get("deadline"): + timeline_items.append({ + "id": f"campaign_{campaign['id']}", + "type": "campaign_deadline", + "title": "Campaign Deadline", + "description": f"{campaign['title']} - {campaign['deadline'][:10]}", + "date": campaign["deadline"], + "priority": "high" + }) + + # Get payments with due dates + payments = safe_supabase_query( + lambda: supabase.table("sponsorship_payments").select("*").eq("brand_id", brand_id).eq("status", "pending").execute(), + "Failed to fetch payments" + ) + + for payment in payments: + if payment.get("due_date"): + timeline_items.append({ + "id": f"payment_{payment['id']}", + "type": "payment_due", + "title": "Payment Due", + "description": f"Creator Payment - ${payment['amount']}", + "date": payment["due_date"], + "priority": "medium" + }) + + # Get content review deadlines (mock data for now) + timeline_items.append({ + "id": "content_review_1", + "type": "content_review", + "title": "Content Review", + "description": "Tech Review Video - Aug 14", + "date": "2024-08-14", + "priority": "medium" + }) + + # Sort by date + timeline_items.sort(key=lambda x: x["date"]) + + return { + "timeline": timeline_items[:5] # Return top 5 items + } + + except HTTPException: + raise + except Exception as e: + logger.error(f"Unexpected error in timeline: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/dashboard/test-brand") +async def get_test_brand(): + """ + Get a test brand ID for testing dashboard endpoints + """ + try: + # Get the first brand user + brand_result = supabase.table("users").select("id, username").eq("role", "brand").limit(1).execute() + + if brand_result.data: + brand = brand_result.data[0] + return { + "brand_id": brand["id"], + "username": brand["username"], + "message": "Use this brand_id for testing dashboard endpoints" + } + else: + return { + "message": "No brand users found in database", + "brand_id": None + } + + except Exception as e: + logger.error(f"Error getting test brand: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +# ============================================================================ +# BRAND PROFILE ROUTES +# ============================================================================ + +@router.post("/profile", response_model=BrandProfileResponse) +async def create_brand_profile(profile: BrandProfileCreate): + """ + Create a new brand profile + """ + try: + profile_id = generate_uuid() + t = current_timestamp() + + response = supabase.table("brand_profiles").insert({ + "id": profile_id, + "user_id": profile.user_id, + "company_name": profile.company_name, + "website": profile.website, + "industry": profile.industry, + "contact_person": profile.contact_person, + "contact_email": profile.contact_email, + "created_at": t + }).execute() + + if response.data: + return BrandProfileResponse(**response.data[0]) + else: + raise HTTPException(status_code=400, detail="Failed to create brand profile") + + except Exception as e: + logger.error(f"Error creating brand profile: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/profile/{user_id}", response_model=BrandProfileResponse) +async def get_brand_profile(user_id: str): + """ + Get brand profile by user ID + """ + try: + result = supabase.table("brand_profiles").select("*").eq("user_id", user_id).execute() + + if result.data: + return BrandProfileResponse(**result.data[0]) + else: + raise HTTPException(status_code=404, detail="Brand profile not found") + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching brand profile: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.put("/profile/{user_id}", response_model=BrandProfileResponse) +async def update_brand_profile(user_id: str, profile_update: BrandProfileUpdate): + """ + Update brand profile + """ + try: + update_data = profile_update.dict(exclude_unset=True) + + response = supabase.table("brand_profiles").update(update_data).eq("user_id", user_id).execute() + + if response.data: + return BrandProfileResponse(**response.data[0]) + else: + raise HTTPException(status_code=404, detail="Brand profile not found") + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error updating brand profile: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +# ============================================================================ +# CAMPAIGN MANAGEMENT ROUTES +# ============================================================================ + +@router.get("/campaigns") +async def get_brand_campaigns(brand_id: str = Query(..., description="Brand user ID")): + """ + Get all campaigns for a brand + """ + # Validate brand_id format + validate_uuid_format(brand_id, "brand_id") + + campaigns = safe_supabase_query( + lambda: supabase.table("sponsorships").select("*").eq("brand_id", brand_id).execute(), + "Failed to fetch brand campaigns" + ) + + return campaigns + +@router.get("/campaigns/{campaign_id}") +async def get_campaign_details(campaign_id: str, brand_id: str = Query(..., description="Brand user ID")): + """ + Get specific campaign details + """ + # Validate IDs format + validate_uuid_format(campaign_id, "campaign_id") + validate_uuid_format(brand_id, "brand_id") + + try: + result = supabase.table("sponsorships").select("*").eq("id", campaign_id).eq("brand_id", brand_id).execute() + + if result.data: + return result.data[0] + else: + raise HTTPException(status_code=404, detail="Campaign not found") + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching campaign details: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.post("/campaigns") +async def create_campaign(campaign: SponsorshipCreate): + """ + Create a new campaign + """ + # Validate brand_id format + validate_uuid_format(campaign.brand_id, "brand_id") + + # Additional business logic validation + if campaign.budget and campaign.budget < 0: + raise HTTPException(status_code=400, detail="Budget cannot be negative") + + if campaign.engagement_minimum and campaign.engagement_minimum < 0: + raise HTTPException(status_code=400, detail="Engagement minimum cannot be negative") + + try: + campaign_id = generate_uuid() + t = current_timestamp() + + response = supabase.table("sponsorships").insert({ + "id": campaign_id, + "brand_id": campaign.brand_id, + "title": campaign.title, + "description": campaign.description, + "required_audience": campaign.required_audience, + "budget": campaign.budget, + "engagement_minimum": campaign.engagement_minimum, + "status": "open", + "created_at": t + }).execute() + + if response.data: + return response.data[0] + else: + raise HTTPException(status_code=400, detail="Failed to create campaign") + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error creating campaign: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.put("/campaigns/{campaign_id}") +async def update_campaign(campaign_id: str, campaign_update: dict, brand_id: str = Query(..., description="Brand user ID")): + """ + Update campaign details + """ + try: + # Verify campaign belongs to brand + existing = supabase.table("sponsorships").select("*").eq("id", campaign_id).eq("brand_id", brand_id).execute() + if not existing.data: + raise HTTPException(status_code=404, detail="Campaign not found") + + response = supabase.table("sponsorships").update(campaign_update).eq("id", campaign_id).execute() + + if response.data: + return response.data[0] + else: + raise HTTPException(status_code=400, detail="Failed to update campaign") + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error updating campaign: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.delete("/campaigns/{campaign_id}") +async def delete_campaign(campaign_id: str, brand_id: str = Query(..., description="Brand user ID")): + """ + Delete a campaign + """ + try: + # Verify campaign belongs to brand + existing = supabase.table("sponsorships").select("*").eq("id", campaign_id).eq("brand_id", brand_id).execute() + if not existing.data: + raise HTTPException(status_code=404, detail="Campaign not found") + + response = supabase.table("sponsorships").delete().eq("id", campaign_id).execute() + + return {"message": "Campaign deleted successfully"} + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error deleting campaign: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +# ============================================================================ +# CREATOR MATCHING ROUTES +# ============================================================================ + +@router.get("/creators/matches", response_model=List[CreatorMatchResponse]) +async def get_creator_matches(brand_id: str = Query(..., description="Brand user ID")): + """ + Get AI-matched creators for a brand + """ + # Validate brand_id format + validate_uuid_format(brand_id, "brand_id") + + try: + result = supabase.table("creator_matches").select("*").eq("brand_id", brand_id).order("match_score", desc=True).execute() + + matches = [] + if result.data: + for match in result.data: + # Get creator details + creator_result = supabase.table("users").select("*").eq("id", match["creator_id"]).execute() + if creator_result.data: + creator = creator_result.data[0] + match["creator_name"] = creator.get("username", "Unknown") + match["creator_role"] = creator.get("role", "creator") + + matches.append(CreatorMatchResponse(**match)) + + return matches + + except Exception as e: + logger.error(f"Error fetching creator matches: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/creators/search") +async def search_creators( + brand_id: str = Query(..., description="Brand user ID"), + industry: Optional[str] = Query(None, description="Industry filter"), + min_engagement: Optional[float] = Query(None, description="Minimum engagement rate"), + location: Optional[str] = Query(None, description="Location filter") +): + """ + Search for creators based on criteria + """ + try: + # Get all creators + creators_result = supabase.table("users").select("*").eq("role", "creator").execute() + creators = creators_result.data if creators_result.data else [] + + # Get audience insights for filtering + insights_result = supabase.table("audience_insights").select("*").execute() + insights = insights_result.data if insights_result.data else [] + + # Create insights lookup + insights_lookup = {insight["user_id"]: insight for insight in insights} + + # Filter creators based on criteria + filtered_creators = [] + for creator in creators: + creator_insights = insights_lookup.get(creator["id"]) + + # Apply filters + if min_engagement and creator_insights: + if creator_insights.get("engagement_rate", 0) < min_engagement: + continue + + # Add creator with insights + creator_data = { + **creator, + "audience_insights": creator_insights + } + filtered_creators.append(creator_data) + + return filtered_creators + + except Exception as e: + logger.error(f"Error searching creators: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/creators/{creator_id}/profile") +async def get_creator_profile(creator_id: str, brand_id: str = Query(..., description="Brand user ID")): + """ + Get detailed creator profile + """ + try: + # Get creator details + creator_result = supabase.table("users").select("*").eq("id", creator_id).eq("role", "creator").execute() + if not creator_result.data: + raise HTTPException(status_code=404, detail="Creator not found") + + creator = creator_result.data[0] + + # Get creator's audience insights + insights_result = supabase.table("audience_insights").select("*").eq("user_id", creator_id).execute() + insights = insights_result.data[0] if insights_result.data else None + + # Get creator's posts + posts_result = supabase.table("user_posts").select("*").eq("user_id", creator_id).execute() + posts = posts_result.data if posts_result.data else [] + + # Calculate match score (simplified algorithm) + match_score = 0.85 # Placeholder - would implement actual AI matching + + return { + "creator": creator, + "audience_insights": insights, + "posts": posts, + "match_score": match_score + } + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching creator profile: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +# ============================================================================ +# ANALYTICS ROUTES +# ============================================================================ + +@router.get("/analytics/performance") +async def get_campaign_performance(brand_id: str = Query(..., description="Brand user ID")): + """ + Get campaign performance analytics + """ + try: + # Get brand's campaigns + campaigns_result = supabase.table("sponsorships").select("*").eq("brand_id", brand_id).execute() + campaigns = campaigns_result.data if campaigns_result.data else [] + + # Get campaign metrics + metrics_result = supabase.table("campaign_metrics").select("*").execute() + metrics = metrics_result.data if metrics_result.data else [] + + # Create metrics lookup + metrics_lookup = {metric["campaign_id"]: metric for metric in metrics} + + # Calculate performance for each campaign + performance_data = [] + for campaign in campaigns: + campaign_metrics = metrics_lookup.get(campaign["id"], {}) + + performance = { + "campaign_id": campaign["id"], + "campaign_title": campaign["title"], + "impressions": campaign_metrics.get("impressions", 0), + "clicks": campaign_metrics.get("clicks", 0), + "conversions": campaign_metrics.get("conversions", 0), + "revenue": float(campaign_metrics.get("revenue", 0)), + "engagement_rate": campaign_metrics.get("engagement_rate", 0), + "roi": 0.0 # Calculate ROI based on budget and revenue + } + + # Calculate ROI + if campaign.get("budget") and performance["revenue"]: + performance["roi"] = (performance["revenue"] - float(campaign["budget"])) / float(campaign["budget"]) * 100 + + performance_data.append(performance) + + return performance_data + + except Exception as e: + logger.error(f"Error fetching campaign performance: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/analytics/revenue") +async def get_revenue_analytics(brand_id: str = Query(..., description="Brand user ID")): + """ + Get revenue analytics + """ + try: + # Get completed payments + payments_result = supabase.table("sponsorship_payments").select("*").eq("brand_id", brand_id).eq("status", "completed").execute() + payments = payments_result.data if payments_result.data else [] + + # Calculate revenue metrics + total_revenue = sum(float(payment.get("amount", 0)) for payment in payments) + avg_payment = total_revenue / len(payments) if payments else 0 + + # Get pending payments + pending_result = supabase.table("sponsorship_payments").select("*").eq("brand_id", brand_id).eq("status", "pending").execute() + pending_payments = pending_result.data if pending_result.data else [] + pending_revenue = sum(float(payment.get("amount", 0)) for payment in pending_payments) + + return { + "total_revenue": total_revenue, + "average_payment": avg_payment, + "pending_revenue": pending_revenue, + "total_payments": len(payments), + "pending_payments": len(pending_payments) + } + + except Exception as e: + logger.error(f"Error fetching revenue analytics: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +# ============================================================================ +# CONTRACT MANAGEMENT ROUTES +# ============================================================================ + +@router.get("/contracts") +async def get_brand_contracts(brand_id: str = Query(..., description="Brand user ID")): + """ + Get all contracts for a brand + """ + try: + result = supabase.table("contracts").select("*").eq("brand_id", brand_id).execute() + return result.data if result.data else [] + + except Exception as e: + logger.error(f"Error fetching brand contracts: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.post("/contracts") +async def create_contract(contract: ContractCreate): + """ + Create a new contract + """ + try: + contract_id = generate_uuid() + t = current_timestamp() + + response = supabase.table("contracts").insert({ + "id": contract_id, + "sponsorship_id": contract.sponsorship_id, + "creator_id": contract.creator_id, + "brand_id": contract.brand_id, + "contract_url": contract.contract_url, + "status": contract.status, + "created_at": t + }).execute() + + if response.data: + return response.data[0] + else: + raise HTTPException(status_code=400, detail="Failed to create contract") + + except Exception as e: + logger.error(f"Error creating contract: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.put("/contracts/{contract_id}/status") +async def update_contract_status( + contract_id: str, + status: str = Query(..., description="New contract status"), + brand_id: str = Query(..., description="Brand user ID") +): + """ + Update contract status + """ + try: + # Verify contract belongs to brand + existing = supabase.table("contracts").select("*").eq("id", contract_id).eq("brand_id", brand_id).execute() + if not existing.data: + raise HTTPException(status_code=404, detail="Contract not found") + + response = supabase.table("contracts").update({"status": status}).eq("id", contract_id).execute() + + if response.data: + return response.data[0] + else: + raise HTTPException(status_code=400, detail="Failed to update contract status") + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error updating contract status: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + + +# ============================================================================ +# APPLICATION MANAGEMENT ROUTES +# ============================================================================ + +@router.get("/applications", response_model=List[SponsorshipApplicationResponse]) +async def get_brand_applications(brand_id: str = Query(..., description="Brand user ID")): + """ + Get all applications for brand's campaigns + """ + # Validate brand_id format + validate_uuid_format(brand_id, "brand_id") + + try: + # Get brand's campaigns first + campaigns = safe_supabase_query( + lambda: supabase.table("sponsorships").select("*").eq("brand_id", brand_id).execute(), + "Failed to fetch campaigns" + ) + + if not campaigns: + return [] + + # Get applications for these campaigns + campaign_ids = [campaign["id"] for campaign in campaigns] + applications = safe_supabase_query( + lambda: supabase.table("sponsorship_applications").select("*").in_("sponsorship_id", campaign_ids).execute(), + "Failed to fetch applications" + ) + + # Enhance applications with creator and campaign details + enhanced_applications = [] + for application in applications: + # Get creator details + creator_result = supabase.table("users").select("*").eq("id", application["creator_id"]).execute() + creator = creator_result.data[0] if creator_result.data else None + + # Get campaign details + campaign_result = supabase.table("sponsorships").select("*").eq("id", application["sponsorship_id"]).execute() + campaign = campaign_result.data[0] if campaign_result.data else None + + enhanced_application = { + **application, + "creator": creator, + "campaign": campaign + } + enhanced_applications.append(enhanced_application) + + return enhanced_applications + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching brand applications: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/applications/{application_id}", response_model=SponsorshipApplicationResponse) +async def get_application_details(application_id: str, brand_id: str = Query(..., description="Brand user ID")): + """ + Get specific application details + """ + # Validate IDs format + validate_uuid_format(application_id, "application_id") + validate_uuid_format(brand_id, "brand_id") + + try: + # Get application + application_result = supabase.table("sponsorship_applications").select("*").eq("id", application_id).execute() + if not application_result.data: + raise HTTPException(status_code=404, detail="Application not found") + + application = application_result.data[0] + + # Verify this application belongs to brand's campaign + campaign_result = supabase.table("sponsorships").select("*").eq("id", application["sponsorship_id"]).eq("brand_id", brand_id).execute() + if not campaign_result.data: + raise HTTPException(status_code=403, detail="Access denied: Application not found in your campaigns") + + # Get creator details + creator_result = supabase.table("users").select("*").eq("id", application["creator_id"]).execute() + creator = creator_result.data[0] if creator_result.data else None + + # Get campaign details + campaign = campaign_result.data[0] + + enhanced_application = { + **application, + "creator": creator, + "campaign": campaign + } + + return enhanced_application + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching application details: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.put("/applications/{application_id}") +async def update_application_status( + application_id: str, + update_data: ApplicationUpdateRequest, + brand_id: str = Query(..., description="Brand user ID") +): + """ + Update application status (accept/reject) + """ + # Validate IDs format + validate_uuid_format(application_id, "application_id") + validate_uuid_format(brand_id, "brand_id") + + try: + # Verify application belongs to brand's campaign + application_result = supabase.table("sponsorship_applications").select("*").eq("id", application_id).execute() + if not application_result.data: + raise HTTPException(status_code=404, detail="Application not found") + + application = application_result.data[0] + campaign_result = supabase.table("sponsorships").select("*").eq("id", application["sponsorship_id"]).eq("brand_id", brand_id).execute() + if not campaign_result.data: + raise HTTPException(status_code=403, detail="Access denied: Application not found in your campaigns") + + # Update application status + update_payload = {"status": update_data.status} + if update_data.notes: + update_payload["notes"] = update_data.notes + + response = supabase.table("sponsorship_applications").update(update_payload).eq("id", application_id).execute() + + if response.data: + return response.data[0] + else: + raise HTTPException(status_code=400, detail="Failed to update application") + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error updating application status: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/applications/summary", response_model=ApplicationSummaryResponse) +async def get_applications_summary(brand_id: str = Query(..., description="Brand user ID")): + """ + Get applications summary and statistics + """ + # Validate brand_id format + validate_uuid_format(brand_id, "brand_id") + + try: + # Get all applications for brand's campaigns + applications = await get_brand_applications(brand_id) + + # Calculate summary + total_applications = len(applications) + pending_applications = len([app for app in applications if app["status"] == "pending"]) + accepted_applications = len([app for app in applications if app["status"] == "accepted"]) + rejected_applications = len([app for app in applications if app["status"] == "rejected"]) + + # Group by campaign + applications_by_campaign = {} + for app in applications: + campaign_title = app.get("campaign", {}).get("title", "Unknown Campaign") + applications_by_campaign[campaign_title] = applications_by_campaign.get(campaign_title, 0) + 1 + + # Recent applications (last 5) + recent_applications = applications[:5] if applications else [] + + return ApplicationSummaryResponse( + total_applications=total_applications, + pending_applications=pending_applications, + accepted_applications=accepted_applications, + rejected_applications=rejected_applications, + applications_by_campaign=applications_by_campaign, + recent_applications=recent_applications + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching applications summary: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + + +# ============================================================================ +# PAYMENT MANAGEMENT ROUTES +# ============================================================================ + +@router.get("/payments", response_model=List[PaymentResponse]) +async def get_brand_payments(brand_id: str = Query(..., description="Brand user ID")): + """ + Get all payments for brand + """ + # Validate brand_id format + validate_uuid_format(brand_id, "brand_id") + + try: + payments = safe_supabase_query( + lambda: supabase.table("sponsorship_payments").select("*").eq("brand_id", brand_id).execute(), + "Failed to fetch payments" + ) + + # Enhance payments with creator and campaign details + enhanced_payments = [] + for payment in payments: + # Get creator details + creator_result = supabase.table("users").select("*").eq("id", payment["creator_id"]).execute() + creator = creator_result.data[0] if creator_result.data else None + + # Get campaign details + campaign_result = supabase.table("sponsorships").select("*").eq("id", payment["sponsorship_id"]).execute() + campaign = campaign_result.data[0] if campaign_result.data else None + + enhanced_payment = { + **payment, + "creator": creator, + "campaign": campaign + } + enhanced_payments.append(enhanced_payment) + + return enhanced_payments + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching brand payments: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/payments/{payment_id}", response_model=PaymentResponse) +async def get_payment_details(payment_id: str, brand_id: str = Query(..., description="Brand user ID")): + """ + Get specific payment details + """ + # Validate IDs format + validate_uuid_format(payment_id, "payment_id") + validate_uuid_format(brand_id, "brand_id") + + try: + payment_result = supabase.table("sponsorship_payments").select("*").eq("id", payment_id).eq("brand_id", brand_id).execute() + if not payment_result.data: + raise HTTPException(status_code=404, detail="Payment not found") + + payment = payment_result.data[0] + + # Get creator details + creator_result = supabase.table("users").select("*").eq("id", payment["creator_id"]).execute() + creator = creator_result.data[0] if creator_result.data else None + + # Get campaign details + campaign_result = supabase.table("sponsorships").select("*").eq("id", payment["sponsorship_id"]).execute() + campaign = campaign_result.data[0] if campaign_result.data else None + + enhanced_payment = { + **payment, + "creator": creator, + "campaign": campaign + } + + return enhanced_payment + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching payment details: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.put("/payments/{payment_id}/status") +async def update_payment_status( + payment_id: str, + status_update: PaymentStatusUpdate, + brand_id: str = Query(..., description="Brand user ID") +): + """ + Update payment status + """ + # Validate IDs format + validate_uuid_format(payment_id, "payment_id") + validate_uuid_format(brand_id, "brand_id") + + try: + # Verify payment belongs to brand + payment_result = supabase.table("sponsorship_payments").select("*").eq("id", payment_id).eq("brand_id", brand_id).execute() + if not payment_result.data: + raise HTTPException(status_code=404, detail="Payment not found") + + # Update payment status + response = supabase.table("sponsorship_payments").update({"status": status_update.status}).eq("id", payment_id).execute() + + if response.data: + return response.data[0] + else: + raise HTTPException(status_code=400, detail="Failed to update payment status") + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error updating payment status: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/payments/analytics", response_model=PaymentAnalyticsResponse) +async def get_payment_analytics(brand_id: str = Query(..., description="Brand user ID")): + """ + Get payment analytics + """ + # Validate brand_id format + validate_uuid_format(brand_id, "brand_id") + + try: + payments = await get_brand_payments(brand_id) + + # Calculate analytics + total_payments = len(payments) + completed_payments = len([p for p in payments if p["status"] == "completed"]) + pending_payments = len([p for p in payments if p["status"] == "pending"]) + total_amount = sum(float(p["amount"]) for p in payments if p["status"] == "completed") + average_payment = total_amount / completed_payments if completed_payments > 0 else 0 + + # Group by month (simplified) + payments_by_month = {} + for payment in payments: + if payment["status"] == "completed": + month = payment["transaction_date"][:7] if payment["transaction_date"] else "unknown" + payments_by_month[month] = payments_by_month.get(month, 0) + float(payment["amount"]) + + return PaymentAnalyticsResponse( + total_payments=total_payments, + completed_payments=completed_payments, + pending_payments=pending_payments, + total_amount=total_amount, + average_payment=average_payment, + payments_by_month=payments_by_month + ) + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching payment analytics: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + + +# ============================================================================ +# CAMPAIGN METRICS MANAGEMENT ROUTES +# ============================================================================ + +@router.post("/campaigns/{campaign_id}/metrics") +async def add_campaign_metrics( + campaign_id: str, + metrics: CampaignMetricsUpdate, + brand_id: str = Query(..., description="Brand user ID") +): + """ + Add metrics to a campaign + """ + # Validate IDs format + validate_uuid_format(campaign_id, "campaign_id") + validate_uuid_format(brand_id, "brand_id") + + try: + # Verify campaign belongs to brand + campaign_result = supabase.table("sponsorships").select("*").eq("id", campaign_id).eq("brand_id", brand_id).execute() + if not campaign_result.data: + raise HTTPException(status_code=404, detail="Campaign not found") + + # Create metrics record + metrics_id = generate_uuid() + t = current_timestamp() + + metrics_data = { + "id": metrics_id, + "campaign_id": campaign_id, + "impressions": metrics.impressions, + "clicks": metrics.clicks, + "conversions": metrics.conversions, + "revenue": metrics.revenue, + "engagement_rate": metrics.engagement_rate, + "recorded_at": t + } + + response = supabase.table("campaign_metrics").insert(metrics_data).execute() + + if response.data: + return response.data[0] + else: + raise HTTPException(status_code=400, detail="Failed to add campaign metrics") + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error adding campaign metrics: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/campaigns/{campaign_id}/metrics") +async def get_campaign_metrics(campaign_id: str, brand_id: str = Query(..., description="Brand user ID")): + """ + Get metrics for a specific campaign + """ + # Validate IDs format + validate_uuid_format(campaign_id, "campaign_id") + validate_uuid_format(brand_id, "brand_id") + + try: + # Verify campaign belongs to brand + campaign_result = supabase.table("sponsorships").select("*").eq("id", campaign_id).eq("brand_id", brand_id).execute() + if not campaign_result.data: + raise HTTPException(status_code=404, detail="Campaign not found") + + # Get campaign metrics + metrics = safe_supabase_query( + lambda: supabase.table("campaign_metrics").select("*").eq("campaign_id", campaign_id).execute(), + "Failed to fetch campaign metrics" + ) + + return metrics + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error fetching campaign metrics: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.put("/campaigns/{campaign_id}/metrics/{metrics_id}") +async def update_campaign_metrics( + campaign_id: str, + metrics_id: str, + metrics_update: CampaignMetricsUpdate, + brand_id: str = Query(..., description="Brand user ID") +): + """ + Update campaign metrics + """ + # Validate IDs format + validate_uuid_format(campaign_id, "campaign_id") + validate_uuid_format(metrics_id, "metrics_id") + validate_uuid_format(brand_id, "brand_id") + + try: + # Verify campaign belongs to brand + campaign_result = supabase.table("sponsorships").select("*").eq("id", campaign_id).eq("brand_id", brand_id).execute() + if not campaign_result.data: + raise HTTPException(status_code=404, detail="Campaign not found") + + # Update metrics + update_data = metrics_update.dict(exclude_unset=True) + response = supabase.table("campaign_metrics").update(update_data).eq("id", metrics_id).eq("campaign_id", campaign_id).execute() + + if response.data: + return response.data[0] + else: + raise HTTPException(status_code=404, detail="Metrics not found") + + except HTTPException: + raise + except Exception as e: + logger.error(f"Error updating campaign metrics: {e}") + raise HTTPException(status_code=500, detail="Internal server error") + +@router.get("/dashboard/analytics") +async def get_dashboard_analytics(brand_id: str = Query(..., description="Brand user ID")): + """ + Get real analytics data for brand dashboard + """ + # Validate brand_id format + validate_uuid_format(brand_id, "brand_id") + + try: + # Get creator matches for this brand + creator_matches = safe_supabase_query( + lambda: supabase.table("creator_matches").select("creator_id").eq("brand_id", brand_id).execute(), + "Failed to fetch creator matches" + ) + + creator_ids = [match["creator_id"] for match in creator_matches] + + if not creator_ids: + return { + "analytics": { + "audienceGrowth": 0, + "bestContentType": "No data", + "topGeographicMarket": "No data", + "trendingTopics": [] + } + } + + # 1. Calculate Audience Growth + audience_growth = 0 + try: + # Get audience insights for creators + audience_data = safe_supabase_query( + lambda: supabase.table("audience_insights").select("*").in_("user_id", creator_ids).execute(), + "Failed to fetch audience insights" + ) + + if audience_data: + # Calculate growth from engagement rates + total_engagement = sum(float(insight.get("engagement_rate", 0)) for insight in audience_data) + avg_engagement = total_engagement / len(audience_data) if audience_data else 0 + audience_growth = min(avg_engagement * 2.5, 25.0) # Realistic growth calculation + except Exception as e: + logger.error(f"Error calculating audience growth: {e}") + audience_growth = 12.5 # Fallback + + # 2. Analyze Best Content Type + best_content_type = "Video" # Default + try: + # Get posts from creators + posts_data = safe_supabase_query( + lambda: supabase.table("user_posts").select("*").in_("user_id", creator_ids).execute(), + "Failed to fetch posts" + ) + + if posts_data: + # Analyze content type performance + content_performance = {} + for post in posts_data: + content_type = post.get("content_type", "post") + engagement = post.get("engagement_metrics", {}) + likes = int(engagement.get("likes", 0)) + + if content_type not in content_performance: + content_performance[content_type] = {"total_likes": 0, "count": 0} + + content_performance[content_type]["total_likes"] += likes + content_performance[content_type]["count"] += 1 + + # Find best performing content type + if content_performance: + best_type = max(content_performance.keys(), + key=lambda x: content_performance[x]["total_likes"] / content_performance[x]["count"]) + best_content_type = best_type.title() + except Exception as e: + logger.error(f"Error analyzing content types: {e}") + + # 3. Analyze Top Geographic Market + top_market = "United States" # Default + try: + # Get audience insights with geographic data + audience_insights = safe_supabase_query( + lambda: supabase.table("audience_insights").select("top_markets").in_("user_id", creator_ids).execute(), + "Failed to fetch audience insights" + ) + + if audience_insights: + market_totals = {} + for insight in audience_insights: + top_markets = insight.get("top_markets", {}) + if isinstance(top_markets, dict): + for market, percentage in top_markets.items(): + if market not in market_totals: + market_totals[market] = 0 + market_totals[market] += float(percentage) + + if market_totals: + top_market = max(market_totals.keys(), key=lambda x: market_totals[x]) + except Exception as e: + logger.error(f"Error analyzing geographic markets: {e}") + + # 4. Analyze Trending Topics + trending_topics = [] + try: + # Get posts and analyze categories + posts_data = safe_supabase_query( + lambda: supabase.table("user_posts").select("category, engagement_metrics").in_("user_id", creator_ids).execute(), + "Failed to fetch posts for trending analysis" + ) + + if posts_data: + category_performance = {} + for post in posts_data: + category = post.get("category", "General") + engagement = post.get("engagement_metrics", {}) + likes = int(engagement.get("likes", 0)) + + if category not in category_performance: + category_performance[category] = {"total_likes": 0, "count": 0} + + category_performance[category]["total_likes"] += likes + category_performance[category]["count"] += 1 + + # Get top 3 trending categories + if category_performance: + sorted_categories = sorted(category_performance.keys(), + key=lambda x: category_performance[x]["total_likes"] / category_performance[x]["count"], + reverse=True) + trending_topics = sorted_categories[:3] + except Exception as e: + logger.error(f"Error analyzing trending topics: {e}") + trending_topics = ["Tech Reviews", "Fashion", "Fitness"] # Fallback + + return { + "analytics": { + "audienceGrowth": round(audience_growth, 1), + "bestContentType": best_content_type, + "topGeographicMarket": top_market, + "trendingTopics": trending_topics + } + } + + except HTTPException: + raise + except Exception as e: + logger.error(f"Unexpected error in analytics: {e}") + raise HTTPException(status_code=500, detail="Internal server error") \ No newline at end of file diff --git a/Backend/app/routes/contracts.py b/Backend/app/routes/contracts.py new file mode 100644 index 0000000..308890f --- /dev/null +++ b/Backend/app/routes/contracts.py @@ -0,0 +1,1283 @@ +from fastapi import APIRouter, HTTPException, Depends, Query +from fastapi.responses import FileResponse +from typing import List, Optional, Dict, Any +from datetime import datetime, date +from pydantic import BaseModel +import httpx +import os +import json +from supabase import create_client, Client +from dotenv import load_dotenv + +# Load environment variables +load_dotenv() +url: str = os.getenv("SUPABASE_URL") +key: str = os.getenv("SUPABASE_KEY") +if not url or not key: + raise ValueError("SUPABASE_URL and SUPABASE_KEY must be set in environment variables") +supabase: Client = create_client(url, key) + +router = APIRouter(prefix="/api/contracts", tags=["contracts"]) + +# ============================================================================ +# PYDANTIC MODELS FOR CONTRACTS +# ============================================================================ + +class ContractBase(BaseModel): + sponsorship_id: Optional[str] = None + creator_id: str + brand_id: str + contract_title: Optional[str] = None + contract_type: str = "one-time" + terms_and_conditions: Optional[Dict[str, Any]] = None + payment_terms: Optional[Dict[str, Any]] = None + deliverables: Optional[Dict[str, Any]] = None + start_date: Optional[str] = None + end_date: Optional[str] = None + total_budget: Optional[float] = None + payment_schedule: Optional[Dict[str, Any]] = None + legal_compliance: Optional[Dict[str, Any]] = None + +class ContractCreate(ContractBase): + pass + +class ContractUpdate(BaseModel): + contract_title: Optional[str] = None + contract_type: Optional[str] = None + terms_and_conditions: Optional[Dict[str, Any]] = None + payment_terms: Optional[Dict[str, Any]] = None + deliverables: Optional[Dict[str, Any]] = None + start_date: Optional[str] = None + end_date: Optional[str] = None + total_budget: Optional[float] = None + payment_schedule: Optional[Dict[str, Any]] = None + legal_compliance: Optional[Dict[str, Any]] = None + status: Optional[str] = None + +class ContractUpdateAdd(BaseModel): + comments: Optional[str] = None + status_update: Optional[str] = None + budget_adjustment: Optional[float] = None + new_deliverables: Optional[str] = None + timeline_update: Optional[str] = None + additional_terms: Optional[str] = None + deliverable_status_updates: Optional[List[Dict[str, Any]]] = None + update_timestamp: Optional[str] = None + updated_by: Optional[str] = None + +class ContractResponse(ContractBase): + id: str + contract_url: Optional[str] = None + status: str + created_at: str + updated_at: Optional[str] = None + comments: Optional[List[Dict[str, Any]]] = None + update_history: Optional[List[Dict[str, Any]]] = None + +class ContractTemplateBase(BaseModel): + template_name: str + template_type: str + industry: Optional[str] = None + terms_template: Optional[Dict[str, Any]] = None + payment_terms_template: Optional[Dict[str, Any]] = None + deliverables_template: Optional[Dict[str, Any]] = None + is_public: bool = False + +class ContractTemplateCreate(ContractTemplateBase): + pass + +class ContractTemplateResponse(ContractTemplateBase): + id: str + created_by: Optional[str] = None + is_active: bool + created_at: str + updated_at: str + +class MilestoneBase(BaseModel): + milestone_name: str + description: Optional[str] = None + due_date: str + payment_amount: float + completion_criteria: Optional[Dict[str, Any]] = None + +class MilestoneCreate(MilestoneBase): + pass + +class MilestoneUpdate(BaseModel): + milestone_name: Optional[str] = None + description: Optional[str] = None + due_date: Optional[str] = None + payment_amount: Optional[float] = None + status: Optional[str] = None + completion_criteria: Optional[Dict[str, Any]] = None + +class MilestoneResponse(MilestoneBase): + id: str + contract_id: str + status: str + completed_at: Optional[str] = None + created_at: str + updated_at: str + +class DeliverableBase(BaseModel): + deliverable_type: str + description: Optional[str] = None + platform: str + requirements: Optional[Dict[str, Any]] = None + due_date: str + +class DeliverableCreate(DeliverableBase): + pass + +class DeliverableUpdate(BaseModel): + deliverable_type: Optional[str] = None + description: Optional[str] = None + platform: Optional[str] = None + requirements: Optional[Dict[str, Any]] = None + due_date: Optional[str] = None + status: Optional[str] = None + content_url: Optional[str] = None + approval_status: Optional[str] = None + approval_notes: Optional[str] = None + +class DeliverableResponse(DeliverableBase): + id: str + contract_id: str + status: str + content_url: Optional[str] = None + approval_status: str + approval_notes: Optional[str] = None + submitted_at: Optional[str] = None + approved_at: Optional[str] = None + created_at: str + updated_at: str + +class PaymentBase(BaseModel): + amount: float + payment_type: str + due_date: str + payment_method: Optional[str] = None + payment_notes: Optional[str] = None + +class PaymentCreate(PaymentBase): + pass + +class PaymentUpdate(BaseModel): + amount: Optional[float] = None + payment_type: Optional[str] = None + status: Optional[str] = None + due_date: Optional[str] = None + paid_date: Optional[datetime] = None + payment_method: Optional[str] = None + transaction_id: Optional[str] = None + payment_notes: Optional[str] = None + +class PaymentResponse(PaymentBase): + id: str + contract_id: str + milestone_id: Optional[str] = None + status: str + paid_date: Optional[str] = None + transaction_id: Optional[str] = None + created_at: str + updated_at: str + +class CommentBase(BaseModel): + comment: str + comment_type: str = "general" + is_internal: bool = False + parent_comment_id: Optional[str] = None + +class CommentCreate(CommentBase): + pass + +class CommentResponse(CommentBase): + id: str + contract_id: str + user_id: str + created_at: str + +class AnalyticsResponse(BaseModel): + id: str + contract_id: str + performance_metrics: Optional[Dict[str, Any]] = None + engagement_data: Optional[Dict[str, Any]] = None + revenue_generated: float = 0 + roi_percentage: float = 0 + cost_per_engagement: float = 0 + cost_per_click: float = 0 + recorded_at: str + +class NotificationResponse(BaseModel): + id: str + contract_id: str + user_id: str + notification_type: str + title: str + message: str + is_read: bool + created_at: str + +# ============================================================================ +# CONTRACT CRUD OPERATIONS +# ============================================================================ + +@router.post("/", response_model=ContractResponse) +async def create_contract(contract: ContractCreate): + """Create a new contract""" + try: + # Insert contract + result = supabase.table("contracts").insert({ + "sponsorship_id": contract.sponsorship_id, + "creator_id": contract.creator_id, + "brand_id": contract.brand_id, + "contract_title": contract.contract_title, + "contract_type": contract.contract_type, + "terms_and_conditions": contract.terms_and_conditions, + "payment_terms": contract.payment_terms, + "deliverables": contract.deliverables, + "start_date": contract.start_date, + "end_date": contract.end_date, + "total_budget": contract.total_budget, + "payment_schedule": contract.payment_schedule, + "legal_compliance": contract.legal_compliance, + "status": "draft" + }).execute() + + if result.data: + return ContractResponse(**result.data[0]) + else: + raise HTTPException(status_code=400, detail="Failed to create contract") + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error creating contract: {str(e)}") + +@router.get("/", response_model=List[ContractResponse]) +async def get_contracts( + brand_id: Optional[str] = Query(None, description="Filter by brand ID"), + creator_id: Optional[str] = Query(None, description="Filter by creator ID"), + status: Optional[str] = Query(None, description="Filter by status"), + limit: int = Query(50, description="Number of contracts to return"), + offset: int = Query(0, description="Number of contracts to skip") +): + """Get all contracts with optional filtering""" + try: + query = supabase.table("contracts").select("*") + + if brand_id: + query = query.eq("brand_id", brand_id) + if creator_id: + query = query.eq("creator_id", creator_id) + if status: + query = query.eq("status", status) + + query = query.range(offset, offset + limit - 1) + result = query.execute() + + return [ContractResponse(**contract) for contract in result.data] + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error fetching contracts: {str(e)}") + +@router.get("/search") +async def search_contracts( + query: str = Query(..., description="Search term"), + brand_id: Optional[str] = Query(None, description="Filter by brand ID"), + creator_id: Optional[str] = Query(None, description="Filter by creator ID"), + status: Optional[str] = Query(None, description="Filter by status"), + limit: int = Query(20, description="Number of results to return") +): + """Search contracts by title, description, or other fields""" + try: + # Get all contracts first (since Supabase doesn't support OR conditions easily) + search_query = supabase.table("contracts").select("*") + + # Add filters + if brand_id: + search_query = search_query.eq("brand_id", brand_id) + if creator_id: + search_query = search_query.eq("creator_id", creator_id) + if status: + search_query = search_query.eq("status", status) + + result = search_query.execute() + contracts = result.data + + # Filter by search term in multiple fields + query_lower = query.lower() + filtered_contracts = [] + + for contract in contracts: + # Search in contract_title, creator_id, brand_id + contract_title = (contract.get("contract_title") or "").lower() + creator_id = (contract.get("creator_id") or "").lower() + brand_id = (contract.get("brand_id") or "").lower() + + if (query_lower in contract_title or + query_lower in creator_id or + query_lower in brand_id): + filtered_contracts.append(contract) + + # Apply limit + limited_contracts = filtered_contracts[:limit] + + return [ContractResponse(**contract) for contract in limited_contracts] + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error searching contracts: {str(e)}") + +@router.get("/{contract_id}", response_model=ContractResponse) +async def get_contract(contract_id: str): + """Get a specific contract by ID""" + try: + result = supabase.table("contracts").select("*").eq("id", contract_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="Contract not found") + + return ContractResponse(**result.data[0]) + + except HTTPException: + raise + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error fetching contract: {str(e)}") + +@router.put("/{contract_id}", response_model=ContractResponse) +async def update_contract(contract_id: str, contract_update: ContractUpdate): + """Update a contract""" + try: + print(f"Updating contract {contract_id} with data: {contract_update.dict()}") + print(f"Raw request data: {contract_update}") + + # Validate the contract exists first + existing_contract = supabase.table("contracts").select("*").eq("id", contract_id).execute() + if not existing_contract.data: + raise HTTPException(status_code=404, detail="Contract not found") + + update_data = contract_update.dict(exclude_unset=True) + if update_data: + update_data["updated_at"] = datetime.utcnow().isoformat() + + print(f"Final update data: {update_data}") + print(f"JSON stringified update data: {json.dumps(update_data, default=str)}") + + # Check for any problematic data types + for key, value in update_data.items(): + if value is not None: + print(f"Field {key}: {type(value)} = {value}") + + result = supabase.table("contracts").update(update_data).eq("id", contract_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="Contract not found") + + print(f"Updated contract data: {result.data[0]}") + + try: + return ContractResponse(**result.data[0]) + except Exception as validation_error: + print(f"Validation error creating ContractResponse: {validation_error}") + print(f"Contract data: {result.data[0]}") + raise HTTPException(status_code=500, detail=f"Error creating response: {str(validation_error)}") + + except HTTPException: + raise + except Exception as e: + print(f"Error updating contract {contract_id}: {str(e)}") + print(f"Contract update data: {contract_update.dict()}") + import traceback + print(f"Full traceback: {traceback.format_exc()}") + raise HTTPException(status_code=500, detail=f"Error updating contract: {str(e)}") + +@router.post("/{contract_id}/updates") +async def add_contract_update(contract_id: str, update_data: ContractUpdateAdd): + """ + Add an update to a contract (preserves existing data and adds new data on top) + """ + try: + print(f"Adding contract update for {contract_id}") + print(f"Update data: {update_data.dict()}") + + # Check if contract exists + existing_contract = supabase.table("contracts").select("*").eq("id", contract_id).execute() + if not existing_contract.data: + raise HTTPException(status_code=404, detail="Contract not found") + + contract = existing_contract.data[0] + print(f"Found contract: {contract.get('id')}") + + # Prepare update data + update_payload = {} + + # Handle status update + if update_data.status_update: + update_payload["status"] = update_data.status_update + + # Handle budget adjustment + if update_data.budget_adjustment is not None: + current_budget = contract.get("total_budget", 0) or 0 + new_budget = current_budget + update_data.budget_adjustment + update_payload["total_budget"] = new_budget + + # Handle terms and conditions updates + if update_data.additional_terms or update_data.timeline_update: + current_terms = contract.get("terms_and_conditions", {}) or {} + if isinstance(current_terms, str): + current_terms = {} + + # Add updates to terms + if update_data.additional_terms: + current_terms["additional_notes"] = update_data.additional_terms + if update_data.timeline_update: + current_terms["timeline_updates"] = update_data.timeline_update + + update_payload["terms_and_conditions"] = current_terms + + # Handle deliverables updates + if update_data.new_deliverables: + current_deliverables = contract.get("deliverables", {}) or {} + if isinstance(current_deliverables, str): + current_deliverables = {} + + # Add new deliverables + if "additional_deliverables" not in current_deliverables: + current_deliverables["additional_deliverables"] = [] + + if isinstance(current_deliverables["additional_deliverables"], list): + current_deliverables["additional_deliverables"].append({ + "description": update_data.new_deliverables, + "added_at": update_data.update_timestamp or datetime.now().isoformat(), + "added_by": update_data.updated_by or "system" + }) + + update_payload["deliverables"] = current_deliverables + + # Add update history (excluding comments) + try: + update_history = contract.get("update_history", []) or [] + if not isinstance(update_history, list): + update_history = [] + + # Only add to update history if there are actual updates (not just comments) + has_updates = any([ + update_data.status_update, + update_data.budget_adjustment is not None, + update_data.new_deliverables, + update_data.timeline_update, + update_data.additional_terms, + update_data.deliverable_status_updates + ]) + + if has_updates: + # Create update entry without comments + update_entry = { + "timestamp": update_data.update_timestamp or datetime.now().isoformat(), + "updated_by": update_data.updated_by or "system", + "updates": {k: v for k, v in update_data.dict(exclude_none=True).items() + if k not in ['comments', 'update_timestamp', 'updated_by']} + } + update_history.append(update_entry) + update_payload["update_history"] = update_history + print(f"Added update history entry") + except Exception as e: + print(f"Error handling update history: {str(e)}") + # Continue without update history if there's an issue + + # Handle deliverable status updates + if update_data.deliverable_status_updates: + current_deliverables = contract.get("deliverables", {}) or {} + if isinstance(current_deliverables, str): + current_deliverables = {} + + # Add deliverable status updates + if "status_updates" not in current_deliverables: + current_deliverables["status_updates"] = [] + + for status_update in update_data.deliverable_status_updates: + if status_update.get("new_status"): + current_deliverables["status_updates"].append({ + "deliverable_id": status_update["deliverable_id"], + "new_status": status_update["new_status"], + "notes": status_update.get("notes", ""), + "updated_at": update_data.update_timestamp or datetime.now().isoformat(), + "updated_by": update_data.updated_by or "system" + }) + + update_payload["deliverables"] = current_deliverables + + # Add comments if provided + if update_data.comments: + try: + # Add to comments field or create new + current_comments = contract.get("comments", []) or [] + if not isinstance(current_comments, list): + current_comments = [] + + comment_entry = { + "comment": update_data.comments, + "timestamp": update_data.update_timestamp or datetime.now().isoformat(), + "user": update_data.updated_by or "system" + } + current_comments.append(comment_entry) + update_payload["comments"] = current_comments + print(f"Added comment entry") + except Exception as e: + print(f"Error handling comments: {str(e)}") + # Continue without comments if there's an issue + + # Update the contract + print(f"Final update payload: {update_payload}") + print(f"JSON stringified payload: {json.dumps(update_payload, default=str)}") + + result = supabase.table("contracts").update(update_payload).eq("id", contract_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="Contract not found") + + print(f"Update successful: {result.data}") + + return { + "message": "Contract updated successfully", + "contract_id": contract_id, + "updates_applied": update_payload + } + + except HTTPException: + raise + except Exception as e: + print(f"Error adding contract update {contract_id}: {str(e)}") + print(f"Update data: {update_data.dict()}") + import traceback + print(f"Full traceback: {traceback.format_exc()}") + raise HTTPException(status_code=500, detail=f"Error adding contract update: {str(e)}") + +@router.delete("/{contract_id}") +async def delete_contract(contract_id: str): + """Delete a contract""" + try: + result = supabase.table("contracts").delete().eq("id", contract_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="Contract not found") + + return {"message": "Contract deleted successfully"} + + except HTTPException: + raise + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error deleting contract: {str(e)}") + +# ============================================================================ +# CONTRACT TEMPLATES +# ============================================================================ + +@router.post("/templates", response_model=ContractTemplateResponse) +async def create_contract_template(template: ContractTemplateCreate, user_id: str): + """Create a new contract template""" + try: + result = supabase.table("contract_templates").insert({ + **template.dict(), + "created_by": user_id + }).execute() + + if result.data: + return ContractTemplateResponse(**result.data[0]) + else: + raise HTTPException(status_code=400, detail="Failed to create template") + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error creating template: {str(e)}") + +@router.get("/templates", response_model=List[ContractTemplateResponse]) +async def get_contract_templates( + template_type: Optional[str] = Query(None, description="Filter by template type"), + industry: Optional[str] = Query(None, description="Filter by industry"), + is_public: Optional[bool] = Query(None, description="Filter by public status"), + limit: int = Query(50, description="Number of templates to return"), + offset: int = Query(0, description="Number of templates to skip") +): + """Get all contract templates with optional filtering""" + try: + query = supabase.table("contract_templates").select("*") + + if template_type: + query = query.eq("template_type", template_type) + if industry: + query = query.eq("industry", industry) + if is_public is not None: + query = query.eq("is_public", is_public) + + query = query.eq("is_active", True).range(offset, offset + limit - 1) + result = query.execute() + + return [ContractTemplateResponse(**template) for template in result.data] + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error fetching templates: {str(e)}") + +@router.get("/templates/{template_id}", response_model=ContractTemplateResponse) +async def get_contract_template(template_id: str): + """Get a specific contract template by ID""" + try: + result = supabase.table("contract_templates").select("*").eq("id", template_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="Template not found") + + return ContractTemplateResponse(**result.data[0]) + + except HTTPException: + raise + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error fetching template: {str(e)}") + +# ============================================================================ +# CONTRACT MILESTONES +# ============================================================================ + +@router.post("/{contract_id}/milestones", response_model=MilestoneResponse) +async def create_milestone(contract_id: str, milestone: MilestoneCreate): + """Create a new milestone for a contract""" + try: + result = supabase.table("contract_milestones").insert({ + "contract_id": contract_id, + **milestone.dict() + }).execute() + + if result.data: + return MilestoneResponse(**result.data[0]) + else: + raise HTTPException(status_code=400, detail="Failed to create milestone") + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error creating milestone: {str(e)}") + +@router.get("/{contract_id}/milestones", response_model=List[MilestoneResponse]) +async def get_contract_milestones(contract_id: str): + """Get all milestones for a contract""" + try: + result = supabase.table("contract_milestones").select("*").eq("contract_id", contract_id).execute() + + return [MilestoneResponse(**milestone) for milestone in result.data] + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error fetching milestones: {str(e)}") + +@router.put("/milestones/{milestone_id}", response_model=MilestoneResponse) +async def update_milestone(milestone_id: str, milestone_update: MilestoneUpdate): + """Update a milestone""" + try: + update_data = milestone_update.dict(exclude_unset=True) + if update_data: + update_data["updated_at"] = datetime.utcnow().isoformat() + + result = supabase.table("contract_milestones").update(update_data).eq("id", milestone_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="Milestone not found") + + return MilestoneResponse(**result.data[0]) + + except HTTPException: + raise + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error updating milestone: {str(e)}") + +@router.delete("/milestones/{milestone_id}") +async def delete_milestone(milestone_id: str): + """Delete a milestone""" + try: + result = supabase.table("contract_milestones").delete().eq("id", milestone_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="Milestone not found") + + return {"message": "Milestone deleted successfully"} + + except HTTPException: + raise + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error deleting milestone: {str(e)}") + +# ============================================================================ +# CONTRACT DELIVERABLES +# ============================================================================ + +@router.post("/{contract_id}/deliverables", response_model=DeliverableResponse) +async def create_deliverable(contract_id: str, deliverable: DeliverableCreate): + """Create a new deliverable for a contract""" + try: + result = supabase.table("contract_deliverables").insert({ + "contract_id": contract_id, + **deliverable.dict() + }).execute() + + if result.data: + return DeliverableResponse(**result.data[0]) + else: + raise HTTPException(status_code=400, detail="Failed to create deliverable") + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error creating deliverable: {str(e)}") + +@router.get("/{contract_id}/deliverables", response_model=List[DeliverableResponse]) +async def get_contract_deliverables(contract_id: str): + """Get all deliverables for a contract""" + try: + result = supabase.table("contract_deliverables").select("*").eq("contract_id", contract_id).execute() + + return [DeliverableResponse(**deliverable) for deliverable in result.data] + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error fetching deliverables: {str(e)}") + +@router.put("/deliverables/{deliverable_id}", response_model=DeliverableResponse) +async def update_deliverable(deliverable_id: str, deliverable_update: DeliverableUpdate): + """Update a deliverable""" + try: + update_data = deliverable_update.dict(exclude_unset=True) + if update_data: + update_data["updated_at"] = datetime.utcnow().isoformat() + + result = supabase.table("contract_deliverables").update(update_data).eq("id", deliverable_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="Deliverable not found") + + return DeliverableResponse(**result.data[0]) + + except HTTPException: + raise + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error updating deliverable: {str(e)}") + +@router.delete("/deliverables/{deliverable_id}") +async def delete_deliverable(deliverable_id: str): + """Delete a deliverable""" + try: + result = supabase.table("contract_deliverables").delete().eq("id", deliverable_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="Deliverable not found") + + return {"message": "Deliverable deleted successfully"} + + except HTTPException: + raise + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error deleting deliverable: {str(e)}") + +# ============================================================================ +# CONTRACT PAYMENTS +# ============================================================================ + +@router.post("/{contract_id}/payments", response_model=PaymentResponse) +async def create_payment(contract_id: str, payment: PaymentCreate, milestone_id: Optional[str] = None): + """Create a new payment for a contract""" + try: + result = supabase.table("contract_payments").insert({ + "contract_id": contract_id, + "milestone_id": milestone_id, + **payment.dict() + }).execute() + + if result.data: + return PaymentResponse(**result.data[0]) + else: + raise HTTPException(status_code=400, detail="Failed to create payment") + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error creating payment: {str(e)}") + +@router.get("/{contract_id}/payments", response_model=List[PaymentResponse]) +async def get_contract_payments(contract_id: str): + """Get all payments for a contract""" + try: + result = supabase.table("contract_payments").select("*").eq("contract_id", contract_id).execute() + + return [PaymentResponse(**payment) for payment in result.data] + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error fetching payments: {str(e)}") + +@router.put("/payments/{payment_id}", response_model=PaymentResponse) +async def update_payment(payment_id: str, payment_update: PaymentUpdate): + """Update a payment""" + try: + update_data = payment_update.dict(exclude_unset=True) + if update_data: + update_data["updated_at"] = datetime.utcnow().isoformat() + + result = supabase.table("contract_payments").update(update_data).eq("id", payment_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="Payment not found") + + return PaymentResponse(**result.data[0]) + + except HTTPException: + raise + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error updating payment: {str(e)}") + +@router.delete("/payments/{payment_id}") +async def delete_payment(payment_id: str): + """Delete a payment""" + try: + result = supabase.table("contract_payments").delete().eq("id", payment_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="Payment not found") + + return {"message": "Payment deleted successfully"} + + except HTTPException: + raise + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error deleting payment: {str(e)}") + +# ============================================================================ +# CONTRACT COMMENTS +# ============================================================================ + +@router.post("/{contract_id}/comments", response_model=CommentResponse) +async def create_comment(contract_id: str, comment: CommentCreate, user_id: str): + """Create a new comment for a contract""" + try: + result = supabase.table("contract_comments").insert({ + "contract_id": contract_id, + "user_id": user_id, + **comment.dict() + }).execute() + + if result.data: + return CommentResponse(**result.data[0]) + else: + raise HTTPException(status_code=400, detail="Failed to create comment") + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error creating comment: {str(e)}") + +@router.get("/{contract_id}/comments", response_model=List[CommentResponse]) +async def get_contract_comments(contract_id: str): + """Get all comments for a contract""" + try: + result = supabase.table("contract_comments").select("*").eq("contract_id", contract_id).order("created_at", desc=True).execute() + + return [CommentResponse(**comment) for comment in result.data] + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error fetching comments: {str(e)}") + +@router.delete("/comments/{comment_id}") +async def delete_comment(comment_id: str): + """Delete a comment""" + try: + result = supabase.table("contract_comments").delete().eq("id", comment_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="Comment not found") + + return {"message": "Comment deleted successfully"} + + except HTTPException: + raise + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error deleting comment: {str(e)}") + +# ============================================================================ +# CONTRACT ANALYTICS +# ============================================================================ + +@router.get("/{contract_id}/analytics", response_model=List[AnalyticsResponse]) +async def get_contract_analytics(contract_id: str): + """Get analytics for a contract""" + try: + result = supabase.table("contract_analytics").select("*").eq("contract_id", contract_id).order("recorded_at", desc=True).execute() + + return [AnalyticsResponse(**analytics) for analytics in result.data] + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error fetching analytics: {str(e)}") + +@router.post("/{contract_id}/analytics", response_model=AnalyticsResponse) +async def create_contract_analytics(contract_id: str, analytics_data: Dict[str, Any]): + """Create analytics entry for a contract""" + try: + result = supabase.table("contract_analytics").insert({ + "contract_id": contract_id, + **analytics_data + }).execute() + + if result.data: + return AnalyticsResponse(**result.data[0]) + else: + raise HTTPException(status_code=400, detail="Failed to create analytics entry") + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error creating analytics: {str(e)}") + +# ============================================================================ +# CONTRACT NOTIFICATIONS +# ============================================================================ + +@router.get("/{contract_id}/notifications", response_model=List[NotificationResponse]) +async def get_contract_notifications(contract_id: str, user_id: Optional[str] = None): + """Get notifications for a contract""" + try: + query = supabase.table("contract_notifications").select("*").eq("contract_id", contract_id) + + if user_id: + query = query.eq("user_id", user_id) + + result = query.order("created_at", desc=True).execute() + + return [NotificationResponse(**notification) for notification in result.data] + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error fetching notifications: {str(e)}") + +@router.put("/notifications/{notification_id}/read") +async def mark_notification_read(notification_id: str): + """Mark a notification as read""" + try: + result = supabase.table("contract_notifications").update({"is_read": True}).eq("id", notification_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="Notification not found") + + return {"message": "Notification marked as read"} + + except HTTPException: + raise + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error updating notification: {str(e)}") + +# ============================================================================ +# CONTRACT STATISTICS +# ============================================================================ + +@router.get("/stats/overview") +async def get_contracts_overview(brand_id: Optional[str] = None, creator_id: Optional[str] = None): + """Get overview statistics for contracts""" + try: + # Base query + query = supabase.table("contracts").select("*") + + if brand_id: + query = query.eq("brand_id", brand_id) + if creator_id: + query = query.eq("creator_id", creator_id) + + result = query.execute() + contracts = result.data + + # Calculate statistics + total_contracts = len(contracts) + active_contracts = len([c for c in contracts if c.get("status") in ["signed", "active"]]) + completed_contracts = len([c for c in contracts if c.get("status") == "completed"]) + draft_contracts = len([c for c in contracts if c.get("status") == "draft"]) + + total_budget = sum(c.get("total_budget", 0) for c in contracts if c.get("total_budget")) + + return { + "total_contracts": total_contracts, + "active_contracts": active_contracts, + "completed_contracts": completed_contracts, + "draft_contracts": draft_contracts, + "total_budget": total_budget, + "average_contract_value": total_budget / total_contracts if total_contracts > 0 else 0 + } + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error fetching contract statistics: {str(e)}") + +# ============================================================================ +# CONTRACT SEARCH - ENDPOINT MOVED ABOVE /{contract_id} ROUTE +# ============================================================================ + +@router.get("/{contract_id}/export") +async def export_contract(contract_id: str): + """ + Export contract to a professional text file format + """ + try: + # Get contract data + contract_result = supabase.table("contracts").select("*").eq("id", contract_id).execute() + if not contract_result.data: + raise HTTPException(status_code=404, detail="Contract not found") + + contract = contract_result.data[0] + + # Generate the contract text content + contract_text = generate_contract_text(contract) + + # Create filename + contract_title = contract.get("contract_title", "Contract").replace(" ", "_").replace("/", "-") + date_str = datetime.now().strftime("%Y-%m-%d") + filename = f"{contract_title}-{date_str}.txt" + + # Save to file (in a temp directory) + export_dir = "exports" + os.makedirs(export_dir, exist_ok=True) + file_path = os.path.join(export_dir, filename) + + with open(file_path, 'w', encoding='utf-8') as f: + f.write(contract_text) + + return { + "message": "Contract exported successfully", + "filename": filename, + "file_path": file_path, + "contract_title": contract.get("contract_title", "Contract"), + "export_date": datetime.now().isoformat() + } + + except HTTPException: + raise + except Exception as e: + print(f"Error exporting contract {contract_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error exporting contract: {str(e)}") + +@router.get("/{contract_id}/export/download") +async def download_exported_contract(contract_id: str): + """ + Download the exported contract file + """ + try: + # Get contract data to create filename + contract_result = supabase.table("contracts").select("*").eq("id", contract_id).execute() + if not contract_result.data: + raise HTTPException(status_code=404, detail="Contract not found") + + contract = contract_result.data[0] + contract_title = contract.get("contract_title", "Contract").replace(" ", "_").replace("/", "-") + date_str = datetime.now().strftime("%Y-%m-%d") + filename = f"{contract_title}-{date_str}.txt" + file_path = os.path.join("exports", filename) + + if not os.path.exists(file_path): + # Generate the file if it doesn't exist + contract_text = generate_contract_text(contract) + with open(file_path, 'w', encoding='utf-8') as f: + f.write(contract_text) + + return FileResponse( + path=file_path, + filename=filename, + media_type='text/plain' + ) + + except HTTPException: + raise + except Exception as e: + print(f"Error downloading contract {contract_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error downloading contract: {str(e)}") + +def generate_contract_text(contract: Dict[str, Any]) -> str: + """ + Generate professional contract text with proper formatting + """ + # Header + text = "=" * 80 + "\n" + text += " " * 20 + "CONTRACT DOCUMENT" + "\n" + text += "=" * 80 + "\n\n" + + # Basic Contract Information + text += "📋 CONTRACT OVERVIEW\n" + text += "-" * 40 + "\n" + text += f"Contract Title: {contract.get('contract_title', 'N/A')}\n" + text += f"Contract Type: {contract.get('contract_type', 'N/A')}\n" + text += f"Status: {contract.get('status', 'N/A')}\n" + text += f"Created: {contract.get('created_at', 'N/A')}\n" + text += f"Last Updated: {contract.get('updated_at', 'N/A')}\n\n" + + # Parties Information + text += "👥 PARTIES INVOLVED\n" + text += "-" * 40 + "\n" + text += f"Brand ID: {contract.get('brand_id', 'N/A')}\n" + text += f"Creator ID: {contract.get('creator_id', 'N/A')}\n" + if contract.get('sponsorship_id'): + text += f"Sponsorship ID: {contract.get('sponsorship_id')}\n" + text += "\n" + + # Timeline + text += "📅 TIMELINE\n" + text += "-" * 40 + "\n" + text += f"Start Date: {contract.get('start_date', 'N/A')}\n" + text += f"End Date: {contract.get('end_date', 'N/A')}\n\n" + + # Financial Details + text += "💰 FINANCIAL DETAILS\n" + text += "-" * 40 + "\n" + text += f"Total Budget: ${contract.get('total_budget', 0):,.2f}\n" + + # Payment Terms + payment_terms = contract.get('payment_terms', {}) + if payment_terms: + text += "\nPayment Terms:\n" + if isinstance(payment_terms, dict): + for key, value in payment_terms.items(): + text += f" • {key.replace('_', ' ').title()}: {value}\n" + else: + text += f" {payment_terms}\n" + + # Payment Schedule + payment_schedule = contract.get('payment_schedule', {}) + if payment_schedule: + text += "\nPayment Schedule:\n" + if isinstance(payment_schedule, dict): + for key, value in payment_schedule.items(): + text += f" • {key.replace('_', ' ').title()}: {value}\n" + else: + text += f" {payment_schedule}\n" + text += "\n" + + # Deliverables + text += "📦 DELIVERABLES\n" + text += "-" * 40 + "\n" + deliverables = contract.get('deliverables', {}) + if deliverables: + if isinstance(deliverables, dict): + for key, value in deliverables.items(): + if key == "deliverables_list" and isinstance(value, list): + text += "Deliverables List:\n" + for i, item in enumerate(value, 1): + text += f" {i}. {item}\n" + elif key == "additional_deliverables" and isinstance(value, list): + text += "Additional Deliverables:\n" + for i, item in enumerate(value, 1): + if isinstance(item, dict): + text += f" {i}. {item.get('description', 'N/A')}\n" + else: + text += f" {i}. {item}\n" + elif key == "status_updates" and isinstance(value, list): + text += "Status Updates:\n" + for item in value: + if isinstance(item, dict): + text += f" • {item.get('new_status', 'N/A')}: {item.get('notes', 'N/A')}\n" + else: + text += f"{key.replace('_', ' ').title()}: {value}\n" + else: + text += f"{deliverables}\n" + else: + text += "No deliverables specified\n" + text += "\n" + + # Terms and Conditions + text += "📜 TERMS AND CONDITIONS\n" + text += "-" * 40 + "\n" + terms = contract.get('terms_and_conditions', {}) + if terms: + if isinstance(terms, dict): + for key, value in terms.items(): + if key == "jurisdiction": + text += f"Jurisdiction: {value}\n" + elif key == "dispute_resolution": + text += f"Dispute Resolution: {value}\n" + elif key == "additional_notes": + text += f"Additional Notes: {value}\n" + elif key == "timeline_updates": + text += f"Timeline Updates: {value}\n" + else: + text += f"{key.replace('_', ' ').title()}: {value}\n" + else: + text += f"{terms}\n" + else: + text += "No terms and conditions specified\n" + text += "\n" + + # Legal Compliance + text += "⚖️ LEGAL COMPLIANCE\n" + text += "-" * 40 + "\n" + legal_compliance = contract.get('legal_compliance', {}) + if legal_compliance: + if isinstance(legal_compliance, dict): + for key, value in legal_compliance.items(): + text += f"{key.replace('_', ' ').title()}: {value}\n" + else: + text += f"{legal_compliance}\n" + else: + text += "No legal compliance information specified\n" + text += "\n" + + # Chat History + text += "💬 NEGOTIATION HISTORY\n" + text += "-" * 40 + "\n" + comments = contract.get('comments', []) + if comments and isinstance(comments, list): + for i, comment in enumerate(comments, 1): + if isinstance(comment, dict): + user = comment.get('user', 'Unknown') + timestamp = comment.get('timestamp', 'Unknown time') + message = comment.get('comment', 'No message') + + # Format timestamp + try: + dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00')) + formatted_time = dt.strftime("%B %d, %Y at %I:%M %p") + except: + formatted_time = timestamp + + text += f"\nMessage {i}:\n" + text += f"From: {user}\n" + text += f"Time: {formatted_time}\n" + text += f"Message: {message}\n" + text += "-" * 30 + "\n" + else: + text += "No negotiation history available\n" + text += "\n" + + # Update History (excluding comments) + text += "📝 UPDATE HISTORY\n" + text += "-" * 40 + "\n" + update_history = contract.get("update_history", []) + if update_history and isinstance(update_history, list): + update_count = 0 + for update in update_history: + if isinstance(update, dict): + updates = update.get('updates', {}) + + # Skip updates that only contain comments + if isinstance(updates, dict) and len(updates) == 1 and 'comments' in updates: + continue + + # Skip updates that only have comments field + if isinstance(updates, dict) and all(key in ['comments', 'update_timestamp', 'updated_by'] for key in updates.keys()): + continue + + update_count += 1 + updated_by = update.get('updated_by', 'Unknown') + timestamp = update.get('timestamp', 'Unknown time') + + # Format timestamp + try: + dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00')) + formatted_time = dt.strftime("%B %d, %Y at %I:%M %p") + except: + formatted_time = timestamp + + text += f"\nUpdate {update_count}:\n" + text += f"Updated by: {updated_by}\n" + text += f"Time: {formatted_time}\n" + + if isinstance(updates, dict): + for key, value in updates.items(): + if value and key not in ['update_timestamp', 'updated_by', 'comments']: + text += f" • {key.replace('_', ' ').title()}: {value}\n" + text += "-" * 30 + "\n" + + if update_count == 0: + text += "No contract updates available\n" + else: + text += "No update history available\n" + text += "\n" + + # Footer + text += "=" * 80 + "\n" + text += " " * 20 + "END OF CONTRACT DOCUMENT" + "\n" + text += "=" * 80 + "\n" + text += f"Generated on: {datetime.now().strftime('%B %d, %Y at %I:%M %p')}\n" + text += "Document ID: " + contract.get('id', 'N/A') + "\n" + + return text \ No newline at end of file diff --git a/Backend/app/routes/contracts_ai.py b/Backend/app/routes/contracts_ai.py new file mode 100644 index 0000000..befdec6 --- /dev/null +++ b/Backend/app/routes/contracts_ai.py @@ -0,0 +1,282 @@ +from fastapi import APIRouter, HTTPException +from pydantic import BaseModel +from typing import List, Dict, Any, Optional +import httpx +import os +from datetime import datetime +import json + +router = APIRouter(prefix="/api/contracts/ai", tags=["Contracts AI"]) + +# Initialize Supabase client +from supabase import create_client, Client +supabase: Client = create_client( + os.environ.get("SUPABASE_URL", "https://your-project.supabase.co"), + os.environ.get("SUPABASE_KEY", "your-anon-key") +) + +class ContractQuery(BaseModel): + query: str + contract_id: Optional[str] = None + user_id: Optional[str] = None + +class ContractAnalysis(BaseModel): + contract_id: str + risk_score: float + risk_factors: List[str] + recommendations: List[str] + performance_prediction: str + market_comparison: Dict[str, Any] + +class AIResponse(BaseModel): + response: str + analysis: Optional[ContractAnalysis] = None + suggestions: List[str] = [] + data: Dict[str, Any] = {} + +@router.post("/chat", response_model=AIResponse) +async def contract_ai_chat(query: ContractQuery): + """AI-powered contract assistant for natural language queries""" + + try: + # Get all contracts for context + contracts_response = supabase.table("contracts").select("*").execute() + contracts = contracts_response.data if contracts_response.data else [] + + # Get contract statistics + stats_response = supabase.table("contracts").select("status, total_budget").execute() + stats_data = stats_response.data if stats_response.data else [] + + # Prepare context for AI + context = { + "total_contracts": len(contracts), + "contracts": contracts[:10], # Limit for context + "stats": { + "active": len([c for c in stats_data if c.get("status") == "active"]), + "draft": len([c for c in stats_data if c.get("status") == "draft"]), + "completed": len([c for c in stats_data if c.get("status") == "completed"]), + "total_budget": sum([c.get("total_budget", 0) for c in stats_data]) + } + } + + # Create AI prompt + system_prompt = f"""You are an AI contract assistant for InPactAI, a creator-brand collaboration platform. + +Available data: +- Total contracts: {context['total_contracts']} +- Active contracts: {context['stats']['active']} +- Draft contracts: {context['stats']['draft']} +- Completed contracts: {context['stats']['completed']} +- Total budget: ${context['stats']['total_budget']:,} + +Contract data (first 10): {json.dumps(contracts[:10], indent=2)} + +Your capabilities: +1. Analyze contracts for risks and opportunities +2. Provide contract recommendations +3. Answer questions about contract performance +4. Suggest improvements +5. Compare contracts and trends +6. Predict contract success + +Respond in a helpful, professional tone. If analyzing a specific contract, provide detailed insights. If general questions, provide overview and trends.""" + + user_prompt = f"User Query: {query.query}" + if query.contract_id: + user_prompt += f"\nSpecific Contract ID: {query.contract_id}" + + # Call Groq AI + groq_url = "https://api.groq.com/openai/v1/chat/completions" + headers = { + "Authorization": f"Bearer {os.environ.get('GROQ_API_KEY')}", + "Content-Type": "application/json" + } + + payload = { + "model": "moonshotai/kimi-k2-instruct", + "messages": [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": user_prompt} + ], + "temperature": 0.7, + "max_tokens": 1000 + } + + async with httpx.AsyncClient() as client: + response = await client.post(groq_url, headers=headers, json=payload) + response.raise_for_status() + ai_response = response.json() + + ai_message = ai_response["choices"][0]["message"]["content"] + + # Generate analysis if contract-specific + analysis = None + if query.contract_id: + contract = next((c for c in contracts if c.get("id") == query.contract_id), None) + if contract: + analysis = await generate_contract_analysis(contract, contracts) + + # Extract suggestions from AI response + suggestions = extract_suggestions(ai_message) + + return AIResponse( + response=ai_message, + analysis=analysis, + suggestions=suggestions, + data={"context": context} + ) + + except Exception as e: + raise HTTPException(status_code=500, detail=f"AI processing failed: {str(e)}") + +async def generate_contract_analysis(contract: Dict, all_contracts: List[Dict]) -> ContractAnalysis: + """Generate detailed analysis for a specific contract""" + + # Calculate risk score based on various factors + risk_factors = [] + risk_score = 0.0 + + # Budget risk + if contract.get("total_budget", 0) > 10000: + risk_factors.append("High budget contract") + risk_score += 0.2 + + # Duration risk + if contract.get("start_date") and contract.get("end_date"): + start = datetime.fromisoformat(contract["start_date"].replace("Z", "+00:00")) + end = datetime.fromisoformat(contract["end_date"].replace("Z", "+00:00")) + duration_days = (end - start).days + if duration_days > 90: + risk_factors.append("Long-term contract") + risk_score += 0.15 + + # Status risk + if contract.get("status") == "draft": + risk_factors.append("Contract in draft status") + risk_score += 0.1 + + # Market comparison + similar_contracts = [ + c for c in all_contracts + if c.get("contract_type") == contract.get("contract_type") + and c.get("id") != contract.get("id") + ] + + avg_budget = sum([c.get("total_budget", 0) for c in similar_contracts]) / len(similar_contracts) if similar_contracts else 0 + + market_comparison = { + "similar_contracts_count": len(similar_contracts), + "average_budget": avg_budget, + "budget_percentile": "above_average" if contract.get("total_budget", 0) > avg_budget else "below_average" + } + + # Generate recommendations + recommendations = [] + if risk_score > 0.3: + recommendations.append("Consider breaking down into smaller milestones") + if contract.get("status") == "draft": + recommendations.append("Review and finalize contract terms") + if contract.get("total_budget", 0) > avg_budget * 1.5: + recommendations.append("Consider negotiating budget or adding deliverables") + + # Performance prediction + if risk_score < 0.2: + performance_prediction = "High success probability" + elif risk_score < 0.4: + performance_prediction = "Moderate success probability" + else: + performance_prediction = "Requires careful monitoring" + + return ContractAnalysis( + contract_id=contract.get("id", ""), + risk_score=min(risk_score, 1.0), + risk_factors=risk_factors, + recommendations=recommendations, + performance_prediction=performance_prediction, + market_comparison=market_comparison + ) + +def extract_suggestions(ai_response: str) -> List[str]: + """Extract actionable suggestions from AI response""" + suggestions = [] + + # Simple keyword-based extraction + if "recommend" in ai_response.lower(): + suggestions.append("Review contract recommendations") + if "risk" in ai_response.lower(): + suggestions.append("Check risk assessment") + if "budget" in ai_response.lower(): + suggestions.append("Review budget allocation") + if "timeline" in ai_response.lower(): + suggestions.append("Optimize project timeline") + + return suggestions + +@router.get("/insights") +async def get_contract_insights(): + """Get AI-generated contract insights and trends""" + + try: + # Get contract data + contracts_response = supabase.table("contracts").select("*").execute() + contracts = contracts_response.data if contracts_response.data else [] + + if not contracts: + return {"insights": "No contracts available for analysis"} + + # Calculate insights + total_budget = sum([c.get("total_budget", 0) for c in contracts]) + avg_budget = total_budget / len(contracts) if contracts else 0 + + status_counts = {} + for contract in contracts: + status = contract.get("status", "unknown") + status_counts[status] = status_counts.get(status, 0) + 1 + + # Type analysis + type_counts = {} + for contract in contracts: + contract_type = contract.get("contract_type", "unknown") + type_counts[contract_type] = type_counts.get(contract_type, 0) + 1 + + insights = { + "total_contracts": len(contracts), + "total_budget": total_budget, + "average_budget": avg_budget, + "status_distribution": status_counts, + "type_distribution": type_counts, + "trends": { + "high_value_contracts": len([c for c in contracts if c.get("total_budget", 0) > avg_budget * 2]), + "active_contracts": status_counts.get("active", 0), + "draft_contracts": status_counts.get("draft", 0) + } + } + + return {"insights": insights} + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Failed to generate insights: {str(e)}") + +@router.post("/analyze/{contract_id}") +async def analyze_contract(contract_id: str): + """Deep analysis of a specific contract""" + + try: + # Get specific contract + contract_response = supabase.table("contracts").select("*").eq("id", contract_id).execute() + contract = contract_response.data[0] if contract_response.data else None + + if not contract: + raise HTTPException(status_code=404, detail="Contract not found") + + # Get all contracts for comparison + all_contracts_response = supabase.table("contracts").select("*").execute() + all_contracts = all_contracts_response.data if all_contracts_response.data else [] + + # Generate analysis + analysis = await generate_contract_analysis(contract, all_contracts) + + return {"analysis": analysis} + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}") \ No newline at end of file diff --git a/Backend/app/routes/contracts_generation.py b/Backend/app/routes/contracts_generation.py new file mode 100644 index 0000000..a36ba48 --- /dev/null +++ b/Backend/app/routes/contracts_generation.py @@ -0,0 +1,1019 @@ +from fastapi import APIRouter, HTTPException +from pydantic import BaseModel +from typing import List, Dict, Any, Optional +import httpx +import os +from datetime import datetime, timedelta +import json + +router = APIRouter(prefix="/api/contracts/generation", tags=["Contract Generation"]) + +# Initialize Supabase client +from supabase import create_client, Client +supabase_url = os.environ.get("SUPABASE_URL") +supabase_key = os.environ.get("SUPABASE_KEY") +if not supabase_url or not supabase_key: + raise ValueError("SUPABASE_URL and SUPABASE_KEY must be set in environment variables") +supabase: Client = create_client(supabase_url, supabase_key) + +class ContractGenerationRequest(BaseModel): + creator_id: str + brand_id: str + contract_type: str # "one-time", "recurring", "campaign", "sponsorship", "custom" + custom_contract_type: Optional[str] = None + min_budget: float + max_budget: float + content_type: List[str] # ["instagram_post", "youtube_shorts", "custom", etc.] + custom_content_types: Optional[List[str]] = [] + duration_value: int + duration_unit: str # "days", "weeks", "months", "years" + requirements: str # Natural language description + industry: Optional[str] = None + exclusivity: Optional[str] = "non-exclusive" + compliance_requirements: Optional[List[str]] = [] + jurisdiction: Optional[str] = None + dispute_resolution: Optional[str] = None + custom_jurisdiction: Optional[str] = None + custom_dispute_resolution: Optional[str] = None + +class ContractTemplate(BaseModel): + id: str + name: str + contract_type: str + industry: str + template_data: Dict[str, Any] + usage_count: int + success_rate: float + +class GeneratedContract(BaseModel): + contract_title: str + contract_type: str + custom_contract_type: Optional[str] = None + total_budget: float + start_date: str + end_date: str + duration_value: int + duration_unit: str + content_types: List[str] + custom_content_types: List[str] = [] + terms_and_conditions: Dict[str, Any] + payment_terms: Dict[str, Any] + deliverables: Dict[str, Any] + legal_compliance: Dict[str, Any] + risk_score: float + ai_suggestions: List[str] + pricing_fallback_used: Optional[bool] = False + pricing_fallback_reason: Optional[str] = None + generation_metadata: Optional[Dict[str, Any]] = None + +class ClauseSuggestion(BaseModel): + clause_type: str + title: str + content: str + importance: str # "critical", "important", "optional" + reasoning: str + +@router.get("/user-by-email") +async def get_user_by_email(email: str): + """Get user information by email""" + try: + # Validate email format + if not email or '@' not in email: + raise HTTPException(status_code=400, detail="Invalid email format") + + print(f"Looking up user with email: {email}") + + user_response = supabase.table("users").select("*").eq("email", email).execute() + + print(f"User response: {user_response.data}") + + if not user_response.data: + raise HTTPException(status_code=404, detail=f"User with email '{email}' not found") + + user = user_response.data[0] + return { + "id": user["id"], + "username": user["username"], + "email": user["email"], + "role": user["role"] + } + except HTTPException: + raise + except Exception as e: + print(f"Error in get_user_by_email: {str(e)}") + raise HTTPException(status_code=500, detail=f"Error fetching user: {str(e)}") + +@router.get("/available-users") +async def get_available_users(): + """Get available creator and brand IDs for testing""" + try: + # Get creators + creators_response = supabase.table("users").select("id, username, role").eq("role", "creator").execute() + creators = creators_response.data if creators_response.data else [] + + # Get brands + brands_response = supabase.table("users").select("id, username, role").eq("role", "brand").execute() + brands = brands_response.data if brands_response.data else [] + + return { + "creators": creators, + "brands": brands, + "message": "Available users for contract generation" + } + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error fetching users: {str(e)}") + +@router.post("/generate", response_model=GeneratedContract) +async def generate_smart_contract(request: ContractGenerationRequest): + """Generate a smart contract based on requirements""" + + try: + # Validate creator and brand IDs exist + creator_response = supabase.table("users").select("*").eq("id", request.creator_id).execute() + brand_response = supabase.table("users").select("*").eq("id", request.brand_id).execute() + + if not creator_response.data: + raise HTTPException(status_code=404, detail=f"Creator with ID '{request.creator_id}' not found") + + if not brand_response.data: + raise HTTPException(status_code=404, detail=f"Brand with ID '{request.brand_id}' not found") + + creator = creator_response.data[0] + brand = brand_response.data[0] + + # Validate that creator is actually a creator and brand is actually a brand + if creator.get("role") != "creator": + raise HTTPException(status_code=400, detail=f"User '{request.creator_id}' is not a creator") + + if brand.get("role") != "brand": + raise HTTPException(status_code=400, detail=f"User '{request.brand_id}' is not a brand") + + # Get similar contracts for reference + similar_contracts_response = supabase.table("contracts").select("*").eq("contract_type", request.contract_type).limit(5).execute() + similar_contracts = similar_contracts_response.data if similar_contracts_response.data else [] + + # Calculate budget based on min/max range + budget = (request.min_budget + request.max_budget) / 2 # Use average of min/max + + # Convert duration to weeks for date calculation + duration_weeks = (lambda: { + 'days': request.duration_value / 7, + 'weeks': request.duration_value, + 'months': request.duration_value * 4.33, # Average weeks per month + 'years': request.duration_value * 52 + }.get(request.duration_unit, request.duration_value))() + + # Generate dates + start_date = datetime.now().date() + end_date = start_date + timedelta(weeks=duration_weeks) + + # Create AI prompt for contract generation + # Get jurisdiction details + jurisdiction_info = "" + if request.jurisdiction: + if request.jurisdiction == "custom" and request.custom_jurisdiction: + jurisdiction_info = f"Custom Jurisdiction: {request.custom_jurisdiction}" + else: + jurisdiction_info = f"Governing Jurisdiction: {request.jurisdiction}" + + dispute_info = "" + if request.dispute_resolution: + if request.dispute_resolution == "custom" and request.custom_dispute_resolution: + dispute_info = f"Custom Dispute Resolution: {request.custom_dispute_resolution}" + else: + dispute_info = f"Dispute Resolution: {request.dispute_resolution}" + + # Prepare content types string including custom types + content_types_str = ', '.join(request.content_type) + if request.custom_content_types: + content_types_str += f", {', '.join(request.custom_content_types)}" + + # Prepare contract type string + contract_type_str = request.contract_type + if request.contract_type == 'custom' and request.custom_contract_type: + contract_type_str = request.custom_contract_type + + system_prompt = f"""You are an expert contract lawyer specializing in creator-brand collaborations. Generate a comprehensive contract based on the following requirements: + +Creator Profile: {json.dumps(creator, indent=2)} +Brand Profile: {json.dumps(brand, indent=2)} +Contract Type: {contract_type_str} +Budget: ${budget:,.2f} +Content Types: {content_types_str} +Duration: {request.duration_value} {request.duration_unit} +Requirements: {request.requirements} +Industry: {request.industry or 'General'} +Exclusivity: {request.exclusivity} +{jurisdiction_info} +{dispute_info} + +Similar Contracts for Reference: {json.dumps(similar_contracts[:3], indent=2)} + +IMPORTANT: You must respond with ONLY valid JSON. Do not include any text before or after the JSON. The JSON must have these exact keys: + +{{ + "contract_title": "Professional contract title", + "terms_and_conditions": {{ + "content_guidelines": "Guidelines for content creation", + "usage_rights": "Rights granted to brand", + "exclusivity": "{request.exclusivity}", + "revision_policy": "Number of revisions allowed", + "approval_process": "Content approval process", + "governing_law": "{jurisdiction_info or 'Standard contract law'}", + "dispute_resolution": "{dispute_info or 'Standard dispute resolution'}", + "jurisdiction": "{request.jurisdiction or 'Standard jurisdiction'}" + }}, + "payment_terms": {{ + "currency": "USD", + "payment_schedule": "Payment schedule description", + "payment_method": "Payment method", + "late_fees": "Late payment fees", + "advance_payment": "Advance payment amount", + "final_payment": "Final payment amount" + }}, + "deliverables": {{ + "content_type": "{', '.join(request.content_type)}", + "quantity": "Number of deliverables", + "timeline": "{request.duration_value} {request.duration_unit}", + "format": "Content format requirements", + "specifications": "Detailed specifications" + }}, + "legal_compliance": {{ + "ftc_compliance": true, + "disclosure_required": true, + "disclosure_format": "Required disclosure format", + "data_protection": "Data protection requirements", + "jurisdiction_compliance": "Compliance with {request.jurisdiction or 'standard'} jurisdiction laws" + }}, + "risk_score": 0.3, + "ai_suggestions": [ + "Suggestion 1", + "Suggestion 2", + "Suggestion 3" + ] +}} + +Generate a complete, professional contract that follows this exact JSON structure and incorporates the specified jurisdiction and dispute resolution requirements.""" + + user_prompt = f"Generate a smart contract for: {request.requirements}" + + # Call Groq AI + groq_api_key = os.environ.get('GROQ_API_KEY') + if not groq_api_key: + raise HTTPException(status_code=500, detail="GROQ_API_KEY is not configured. Please set up the API key to generate AI contracts.") + + groq_url = "https://api.groq.com/openai/v1/chat/completions" + headers = { + "Authorization": f"Bearer {groq_api_key}", + "Content-Type": "application/json" + } + + payload = { + "model": "moonshotai/kimi-k2-instruct", + "messages": [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": user_prompt} + ], + "temperature": 0.7, + "max_tokens": 2000 + } + + # Use Groq AI for enhanced contract generation + groq_api_key = os.environ.get('GROQ_API_KEY') + if not groq_api_key: + # Fallback if no API key + contract_data = { + "contract_title": f"{contract_type_str.title()} Contract - {request.industry or 'General'}", + "terms_and_conditions": { + "content_guidelines": "Content must align with brand guidelines and target audience", + "usage_rights": "Brand receives rights to use content across specified platforms", + "exclusivity": request.exclusivity, + "revision_policy": "2 rounds of revisions included", + "approval_process": "Content requires brand approval before publication", + "governing_law": f"Governing law: {request.jurisdiction or 'Standard contract law'}", + "dispute_resolution": f"Dispute resolution: {request.dispute_resolution or 'Standard dispute resolution'}", + "jurisdiction": request.jurisdiction or "Standard jurisdiction" + }, + "payment_terms": { + "currency": "USD", + "payment_schedule": "50% upfront, 50% upon completion", + "payment_method": "Bank transfer or digital payment", + "late_fees": "5% monthly interest on overdue payments", + "advance_payment": f"${request.min_budget * 0.5:,.2f}", + "final_payment": f"${request.max_budget * 0.5:,.2f}" + }, + "deliverables": { + "content_type": content_types_str, + "quantity": "1 deliverable per content type", + "timeline": f"{request.duration_value} {request.duration_unit}", + "format": "High-quality digital content", + "specifications": request.requirements + }, + "legal_compliance": { + "ftc_compliance": True, + "disclosure_required": True, + "disclosure_format": "Clear disclosure of sponsored content", + "data_protection": "GDPR compliant data handling", + "jurisdiction_compliance": f"Compliance with {request.jurisdiction or 'standard'} jurisdiction laws" + }, + "risk_score": calculate_risk_score(request), + "ai_suggestions": generate_ai_suggestions(request, calculate_risk_score(request)) + } + else: + # Use Groq AI for enhanced generation + try: + risk_score = calculate_risk_score(request) + + # Get jurisdiction details for enhanced generation + jurisdiction_info = "" + if request.jurisdiction: + if request.jurisdiction == "custom" and request.custom_jurisdiction: + jurisdiction_info = f"Custom Jurisdiction: {request.custom_jurisdiction}" + else: + jurisdiction_info = f"Governing Jurisdiction: {request.jurisdiction}" + + dispute_info = "" + if request.dispute_resolution: + if request.dispute_resolution == "custom" and request.custom_dispute_resolution: + dispute_info = f"Custom Dispute Resolution: {request.custom_dispute_resolution}" + else: + dispute_info = f"Dispute Resolution: {request.dispute_resolution}" + + system_prompt = f"""You are an expert contract lawyer and risk analyst specializing in creator-brand collaborations. + +Analyze this contract request and provide enhanced contract terms and AI suggestions: + +Contract Details: +- Type: {request.contract_type} +- Budget: ${request.min_budget:,.2f} - ${request.max_budget:,.2f} +- Content Types: {', '.join(request.content_type)} +- Duration: {request.duration_weeks} weeks +- Industry: {request.industry or 'General'} +- Exclusivity: {request.exclusivity} +- Requirements: {request.requirements} +- Compliance Requirements: {', '.join(request.compliance_requirements) if request.compliance_requirements else 'None'} +- Calculated Risk Score: {risk_score:.2f} ({risk_score*100:.0f}%) +{jurisdiction_info and f"- {jurisdiction_info}" or ""} +{dispute_info and f"- {dispute_info}" or ""} + +Respond with ONLY valid JSON in this exact format: +{{ + "contract_title": "Professional contract title", + "terms_and_conditions": {{ + "content_guidelines": "Enhanced guidelines based on content type and industry", + "usage_rights": "Detailed rights specification", + "exclusivity": "{request.exclusivity}", + "revision_policy": "Specific revision terms", + "approval_process": "Detailed approval workflow", + "governing_law": "{jurisdiction_info or 'Standard contract law'}", + "dispute_resolution": "{dispute_info or 'Standard dispute resolution'}", + "jurisdiction": "{request.jurisdiction or 'Standard jurisdiction'}" + }}, + "payment_terms": {{ + "currency": "USD", + "payment_schedule": "Detailed payment schedule", + "payment_method": "Payment method details", + "late_fees": "Late payment terms", + "advance_payment": "Advance payment details", + "final_payment": "Final payment details" + }}, + "deliverables": {{ + "content_type": "{', '.join(request.content_type)}", + "quantity": "Specific quantity details", + "timeline": "{request.duration_value} {request.duration_unit}", + "format": "Detailed format requirements", + "specifications": "Enhanced specifications" + }}, + "legal_compliance": {{ + "ftc_compliance": true, + "disclosure_required": true, + "disclosure_format": "Specific disclosure requirements", + "data_protection": "Enhanced data protection terms", + "jurisdiction_compliance": "Compliance with {request.jurisdiction or 'standard'} jurisdiction laws" + }}, + "risk_score": {risk_score}, + "ai_suggestions": [ + "AI-generated suggestion 1", + "AI-generated suggestion 2", + "AI-generated suggestion 3" + ] +}} + +Focus on: +1. Industry-specific requirements for {request.industry or 'general'} industry +2. Content type-specific guidelines for {', '.join(request.content_type)} +3. Risk mitigation strategies for {risk_score*100:.0f}% risk level +4. Compliance requirements: {', '.join(request.compliance_requirements) if request.compliance_requirements else 'Standard'} +5. Budget optimization for ${request.min_budget:,.2f} - ${request.max_budget:,.2f} range +6. Jurisdiction-specific legal requirements for {request.jurisdiction or 'standard'} jurisdiction +7. Dispute resolution framework: {request.dispute_resolution or 'standard'}""" + + user_prompt = f"Generate enhanced contract terms and AI suggestions for: {request.requirements}" + + groq_url = "https://api.groq.com/openai/v1/chat/completions" + headers = { + "Authorization": f"Bearer {groq_api_key}", + "Content-Type": "application/json" + } + + payload = { + "model": "moonshotai/kimi-k2-instruct", + "messages": [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": user_prompt} + ], + "temperature": 0.7, + "max_tokens": 2000 + } + + async with httpx.AsyncClient() as client: + response = await client.post(groq_url, headers=headers, json=payload) + response.raise_for_status() + ai_response = response.json() + + ai_message = ai_response["choices"][0]["message"]["content"] + + if not ai_message or ai_message.strip() == "": + raise Exception("AI returned empty response") + + # Parse AI response + try: + contract_data = json.loads(ai_message) + # Ensure risk score is preserved + contract_data["risk_score"] = risk_score + except json.JSONDecodeError as json_error: + print(f"AI Response (first 500 chars): {ai_message[:500]}") + raise Exception(f"AI returned invalid JSON: {str(json_error)}") + + except Exception as ai_error: + print(f"AI generation failed: {str(ai_error)}, using fallback") + # Fallback to structured generation + contract_data = { + "contract_title": f"{request.contract_type.title()} Contract - {request.industry or 'General'}", + "terms_and_conditions": { + "content_guidelines": "Content must align with brand guidelines and target audience", + "usage_rights": "Brand receives rights to use content across specified platforms", + "exclusivity": request.exclusivity, + "revision_policy": "2 rounds of revisions included", + "approval_process": "Content requires brand approval before publication" + }, + "payment_terms": { + "currency": "USD", + "payment_schedule": "50% upfront, 50% upon completion", + "payment_method": "Bank transfer or digital payment", + "late_fees": "5% monthly interest on overdue payments", + "advance_payment": f"${request.min_budget * 0.5:,.2f}", + "final_payment": f"${request.max_budget * 0.5:,.2f}" + }, + "deliverables": { + "content_type": ", ".join(request.content_type), + "quantity": "1 deliverable per content type", + "timeline": f"{request.duration_value} {request.duration_unit}", + "format": "High-quality digital content", + "specifications": request.requirements + }, + "legal_compliance": { + "ftc_compliance": True, + "disclosure_required": True, + "disclosure_format": "Clear disclosure of sponsored content", + "data_protection": "GDPR compliant data handling" + }, + "risk_score": calculate_risk_score(request), + "ai_suggestions": generate_ai_suggestions(request, calculate_risk_score(request)) + } + + + + return GeneratedContract( + contract_title=contract_data.get("contract_title", f"{request.contract_type.title()} Contract"), + contract_type=request.contract_type, + custom_contract_type=request.custom_contract_type if request.contract_type == 'custom' else None, + total_budget=budget, + start_date=start_date.isoformat(), + end_date=end_date.isoformat(), + duration_value=request.duration_value, + duration_unit=request.duration_unit, + content_types=request.content_type, + custom_content_types=request.custom_content_types, + terms_and_conditions=contract_data.get("terms_and_conditions", {}), + payment_terms=contract_data.get("payment_terms", {}), + deliverables=contract_data.get("deliverables", {}), + legal_compliance=contract_data.get("legal_compliance", {}), + risk_score=contract_data.get("risk_score", 0.3), + ai_suggestions=contract_data.get("ai_suggestions", []), + pricing_fallback_used=False, # This will be set by the frontend based on pricing recommendation + pricing_fallback_reason=None, # This will be set by the frontend based on pricing recommendation + generation_metadata={ + "ai_generated": True, + "generation_timestamp": datetime.now().isoformat(), + "original_request": { + "requirements": request.requirements, + "industry": request.industry, + "exclusivity": request.exclusivity, + "compliance_requirements": request.compliance_requirements + } + } + ) + + except Exception as e: + import traceback + print(f"Contract generation error: {str(e)}") + print(f"Traceback: {traceback.format_exc()}") + raise HTTPException(status_code=500, detail=f"Contract generation failed: {str(e)}") + +def calculate_risk_score(request: ContractGenerationRequest) -> float: + """Calculate risk score based on contract parameters""" + + risk_score = 0.0 + + # Budget risk factors + budget_range = request.max_budget - request.min_budget + budget_volatility = budget_range / request.max_budget if request.max_budget > 0 else 0 + if budget_volatility > 0.5: # High budget uncertainty + risk_score += 0.2 + elif budget_volatility > 0.3: # Medium budget uncertainty + risk_score += 0.1 + + # Contract type risk + contract_type_risk = { + "one-time": 0.1, + "recurring": 0.15, + "campaign": 0.2, + "sponsorship": 0.25 + } + risk_score += contract_type_risk.get(request.contract_type, 0.15) + + # Duration risk (longer contracts = higher risk) + # Convert duration to weeks for risk calculation + duration_weeks = (lambda: { + 'days': request.duration_value / 7, + 'weeks': request.duration_value, + 'months': request.duration_value * 4.33, + 'years': request.duration_value * 52 + }.get(request.duration_unit, request.duration_value))() + + if duration_weeks > 12: + risk_score += 0.2 + elif duration_weeks > 8: + risk_score += 0.15 + elif duration_weeks > 4: + risk_score += 0.1 + + # Content type risk + content_type_risk = { + # YouTube content types + "youtube_shorts": 0.04, + "youtube_video": 0.05, + "youtube_live": 0.08, + # Instagram content types + "instagram_post": 0.06, + "instagram_reel": 0.07, + "instagram_story": 0.05, + "instagram_live": 0.08, + # TikTok content types + "tiktok_video": 0.12, + "tiktok_live": 0.15, + # Facebook content types + "facebook_post": 0.06, + "facebook_live": 0.08, + # Twitter content types + "twitter_post": 0.07, + "twitter_space": 0.09, + # LinkedIn content types + "linkedin_post": 0.04, + "linkedin_article": 0.05, + # Other content types + "blog_post": 0.03, + "podcast": 0.10, + "newsletter": 0.04, + # Legacy support + "youtube": 0.05, + "instagram": 0.08, + "tiktok": 0.12, + "facebook": 0.06, + "twitter": 0.07, + "linkedin": 0.04, + "blog": 0.03 + } + + # Calculate average content type risk + content_risks = [content_type_risk.get(ct.lower(), 0.1) for ct in request.content_type] + avg_content_risk = sum(content_risks) / len(content_risks) if content_risks else 0.1 + risk_score += avg_content_risk + + # Exclusivity risk + if request.exclusivity == "exclusive": + risk_score += 0.15 # Higher risk for exclusive contracts + elif request.exclusivity == "platform": + risk_score += 0.1 + + # Compliance requirements risk + compliance_risk = len(request.compliance_requirements) * 0.02 + risk_score += min(compliance_risk, 0.1) # Cap at 0.1 + + # Industry risk + high_risk_industries = ["finance", "healthcare", "legal", "pharmaceutical"] + if request.industry and request.industry.lower() in high_risk_industries: + risk_score += 0.1 + + # Requirements complexity risk + requirements_length = len(request.requirements) + if requirements_length > 200: + risk_score += 0.1 + elif requirements_length > 100: + risk_score += 0.05 + + # Cap risk score between 0.1 and 0.9 + risk_score = max(0.1, min(0.9, risk_score)) + + return round(risk_score, 2) + +def generate_ai_suggestions(request: ContractGenerationRequest, risk_score: float) -> List[str]: + """Generate AI suggestions based on contract parameters and risk score""" + + suggestions = [] + + # Budget-related suggestions + budget_range = request.max_budget - request.min_budget + budget_volatility = budget_range / request.max_budget if request.max_budget > 0 else 0 + + if budget_volatility > 0.5: + suggestions.append("Consider setting a more specific budget range to reduce uncertainty") + elif budget_volatility > 0.3: + suggestions.append("Define clear payment milestones to manage budget expectations") + + # Contract type suggestions + if request.contract_type == "sponsorship": + suggestions.append("Include detailed FTC disclosure requirements for sponsored content") + suggestions.append("Specify content usage rights and duration limitations") + elif request.contract_type == "recurring": + suggestions.append("Define performance metrics and review periods") + suggestions.append("Include termination clauses with notice periods") + elif request.contract_type == "campaign": + suggestions.append("Set clear campaign objectives and success metrics") + suggestions.append("Include content approval timeline and revision limits") + + # Duration suggestions + # Convert duration to weeks for suggestions + duration_weeks = (lambda: { + 'days': request.duration_value / 7, + 'weeks': request.duration_value, + 'months': request.duration_value * 4.33, + 'years': request.duration_value * 52 + }.get(request.duration_unit, request.duration_value))() + + if duration_weeks > 8: + suggestions.append("Break down deliverables into phases with interim deadlines") + suggestions.append("Include progress review meetings and milestone payments") + elif duration_weeks > 4: + suggestions.append("Set weekly check-ins to track progress") + + # Content type suggestions + if "tiktok" in request.content_type: + suggestions.append("Include platform-specific guidelines for TikTok content") + if "youtube" in request.content_type: + suggestions.append("Specify video quality requirements and format standards") + if "instagram" in request.content_type: + suggestions.append("Define hashtag usage and tagging requirements") + + # Exclusivity suggestions + if request.exclusivity == "exclusive": + suggestions.append("Clearly define exclusivity scope and duration") + suggestions.append("Include compensation for exclusivity restrictions") + + # Compliance suggestions + if len(request.compliance_requirements) > 2: + suggestions.append("Consider legal review for complex compliance requirements") + + # Risk-based suggestions + if risk_score > 0.7: + suggestions.append("Consider adding performance bonds or insurance requirements") + suggestions.append("Include detailed dispute resolution procedures") + elif risk_score > 0.5: + suggestions.append("Add regular progress reports and quality checkpoints") + elif risk_score < 0.3: + suggestions.append("Keep contract terms simple and straightforward") + + # Industry-specific suggestions + if request.industry and request.industry.lower() in ["finance", "healthcare", "legal"]: + suggestions.append("Include industry-specific compliance and disclosure requirements") + + # Ensure we have at least 3 suggestions + while len(suggestions) < 3: + suggestions.append("Consider adding performance metrics to track campaign success") + if len(suggestions) >= 3: + break + + return suggestions[:5] # Limit to 5 suggestions + +def calculate_budget(budget_range: str, content_types: List[str], duration_value: int, duration_unit: str) -> float: + """Calculate budget based on requirements""" + + # Base rates per content type + base_rates = { + # YouTube content types + "youtube_shorts": 300, + "youtube_video": 1000, + "youtube_live": 1500, + # Instagram content types + "instagram_post": 500, + "instagram_reel": 600, + "instagram_story": 300, + "instagram_live": 800, + # TikTok content types + "tiktok_video": 400, + "tiktok_live": 600, + # Facebook content types + "facebook_post": 450, + "facebook_live": 700, + # Twitter content types + "twitter_post": 300, + "twitter_space": 500, + # LinkedIn content types + "linkedin_post": 600, + "linkedin_article": 800, + # Other content types + "blog_post": 800, + "podcast": 1200, + "newsletter": 400, + # Legacy support + "instagram": 500, + "youtube": 1000, + "tiktok": 400, + "facebook": 450, + "twitter": 300, + "linkedin": 600, + "blog": 800 + } + + # Budget multipliers + budget_multipliers = { + "low": 0.7, + "medium": 1.0, + "high": 1.5 + } + + # Calculate base budget + base_budget = sum(base_rates.get(content_type.lower(), 500) for content_type in content_types) + + # Apply budget range multiplier + budget = base_budget * budget_multipliers.get(budget_range, 1.0) + + # Convert duration to weeks for budget calculation + duration_weeks = (lambda: { + 'days': duration_value / 7, + 'weeks': duration_value, + 'months': duration_value * 4.33, + 'years': duration_value * 52 + }.get(duration_unit, duration_value))() + + # Adjust for duration + if duration_weeks > 4: + budget *= 0.8 # Discount for longer contracts + + return round(budget, 2) + + + +@router.post("/suggest-clauses") +async def suggest_clauses(contract_type: str, industry: str, budget: float): + """Suggest relevant clauses for contract type""" + + try: + # Create AI prompt for clause suggestions + system_prompt = f"""You are a contract law expert. Suggest relevant clauses for a {contract_type} contract in the {industry} industry with a budget of ${budget:,.2f}. + +Provide suggestions in JSON format with this structure: +{{ + "clauses": [ + {{ + "clause_type": "payment", + "title": "Payment Terms", + "content": "Detailed payment clause...", + "importance": "critical", + "reasoning": "Why this clause is important..." + }} + ] +}} + +Focus on: +1. Payment and financial terms +2. Deliverables and quality standards +3. Intellectual property rights +4. Confidentiality and non-disclosure +5. Termination and dispute resolution +6. Compliance and legal requirements""" + + user_prompt = f"Suggest clauses for {contract_type} contract in {industry} industry" + + # Call Groq AI + groq_url = "https://api.groq.com/openai/v1/chat/completions" + headers = { + "Authorization": f"Bearer {os.environ.get('GROQ_API_KEY')}", + "Content-Type": "application/json" + } + + payload = { + "model": "moonshotai/kimi-k2-instruct", + "messages": [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": user_prompt} + ], + "temperature": 0.7, + "max_tokens": 1500 + } + + async with httpx.AsyncClient() as client: + response = await client.post(groq_url, headers=headers, json=payload) + response.raise_for_status() + ai_response = response.json() + + ai_message = ai_response["choices"][0]["message"]["content"] + + # Parse AI response + try: + clause_data = json.loads(ai_message) + return {"clauses": clause_data.get("clauses", [])} + except json.JSONDecodeError: + # Fallback clauses + return {"clauses": generate_fallback_clauses(contract_type, industry)} + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Clause suggestion failed: {str(e)}") + +def generate_fallback_clauses(contract_type: str, industry: str) -> List[Dict[str, Any]]: + """Generate fallback clause suggestions""" + + base_clauses = [ + { + "clause_type": "payment", + "title": "Payment Terms", + "content": "Payment shall be made in accordance with the agreed schedule. Late payments may incur penalties.", + "importance": "critical", + "reasoning": "Ensures timely payment and protects creator cash flow" + }, + { + "clause_type": "deliverables", + "title": "Deliverables and Quality Standards", + "content": "All deliverables must meet agreed quality standards and brand guidelines.", + "importance": "critical", + "reasoning": "Defines expectations and prevents disputes over quality" + }, + { + "clause_type": "intellectual_property", + "title": "Intellectual Property Rights", + "content": "Creator retains ownership of original content. Brand receives usage rights as specified.", + "importance": "important", + "reasoning": "Clarifies ownership and usage rights to prevent conflicts" + }, + { + "clause_type": "confidentiality", + "title": "Confidentiality", + "content": "Both parties agree to maintain confidentiality of proprietary information.", + "importance": "important", + "reasoning": "Protects sensitive business information" + }, + { + "clause_type": "termination", + "title": "Termination", + "content": "Either party may terminate with 30 days written notice.", + "importance": "important", + "reasoning": "Provides clear exit strategy for both parties" + } + ] + + return base_clauses + +@router.post("/validate-compliance") +async def validate_contract_compliance(contract_data: Dict[str, Any]): + """Validate contract for legal compliance""" + + try: + # Create AI prompt for compliance validation + system_prompt = """You are a legal compliance expert specializing in creator-brand contracts. Analyze the provided contract for compliance issues. + +Check for: +1. FTC disclosure requirements +2. GDPR/data protection compliance +3. Intellectual property rights +4. Payment and tax compliance +5. Industry-specific regulations + +Return analysis in JSON format: +{ + "is_compliant": true/false, + "compliance_score": 0.0-1.0, + "issues": ["list of compliance issues"], + "recommendations": ["list of recommendations"], + "risk_level": "low/medium/high" +}""" + + user_prompt = f"Validate compliance for contract: {json.dumps(contract_data, indent=2)}" + + # Call Groq AI + groq_url = "https://api.groq.com/openai/v1/chat/completions" + headers = { + "Authorization": f"Bearer {os.environ.get('GROQ_API_KEY')}", + "Content-Type": "application/json" + } + + payload = { + "model": "moonshotai/kimi-k2-instruct", + "messages": [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": user_prompt} + ], + "temperature": 0.5, + "max_tokens": 1000 + } + + async with httpx.AsyncClient() as client: + response = await client.post(groq_url, headers=headers, json=payload) + response.raise_for_status() + ai_response = response.json() + + ai_message = ai_response["choices"][0]["message"]["content"] + + # Parse AI response + try: + compliance_data = json.loads(ai_message) + return compliance_data + except json.JSONDecodeError: + # Fallback compliance check + return generate_fallback_compliance_check(contract_data) + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Compliance validation failed: {str(e)}") + +def generate_fallback_compliance_check(contract_data: Dict[str, Any]) -> Dict[str, Any]: + """Generate fallback compliance check""" + + issues = [] + recommendations = [] + + # Basic compliance checks + if not contract_data.get("legal_compliance", {}).get("ftc_compliance"): + issues.append("Missing FTC disclosure requirements") + recommendations.append("Add mandatory #ad or #sponsored disclosure") + + if not contract_data.get("terms_and_conditions", {}).get("usage_rights"): + issues.append("Unclear intellectual property rights") + recommendations.append("Define usage rights and ownership clearly") + + if not contract_data.get("payment_terms", {}).get("payment_schedule"): + issues.append("Unclear payment terms") + recommendations.append("Specify payment schedule and late fees") + + compliance_score = 0.7 if len(issues) == 0 else max(0.3, 0.7 - len(issues) * 0.1) + risk_level = "low" if compliance_score > 0.8 else "medium" if compliance_score > 0.6 else "high" + + return { + "is_compliant": len(issues) == 0, + "compliance_score": compliance_score, + "issues": issues, + "recommendations": recommendations, + "risk_level": risk_level + } + +@router.get("/templates") +async def get_contract_templates(): + """Get available contract templates""" + + try: + # Get templates from database + templates_response = supabase.table("contract_templates").select("*").execute() + templates = templates_response.data if templates_response.data else [] + + # If no templates in database, return default templates + if not templates: + templates = [ + { + "id": "template-1", + "name": "Influencer Sponsorship", + "contract_type": "sponsorship", + "industry": "general", + "usage_count": 0, + "success_rate": 0.85 + }, + { + "id": "template-2", + "name": "Content Creation", + "contract_type": "one-time", + "industry": "general", + "usage_count": 0, + "success_rate": 0.90 + }, + { + "id": "template-3", + "name": "Brand Ambassador", + "contract_type": "recurring", + "industry": "general", + "usage_count": 0, + "success_rate": 0.88 + } + ] + + return {"templates": templates} + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Failed to get templates: {str(e)}") \ No newline at end of file diff --git a/Backend/app/routes/post.py b/Backend/app/routes/post.py index a90e313..93d05a1 100644 --- a/Backend/app/routes/post.py +++ b/Backend/app/routes/post.py @@ -22,10 +22,12 @@ load_dotenv() url: str = os.getenv("SUPABASE_URL") key: str = os.getenv("SUPABASE_KEY") +if not url or not key: + raise ValueError("SUPABASE_URL and SUPABASE_KEY must be set in environment variables") supabase: Client = create_client(url, key) # Define Router -router = APIRouter() +router = APIRouter(prefix="/api", tags=["users", "posts", "sponsorships"]) # Helper Functions def generate_uuid(): @@ -57,6 +59,20 @@ async def get_users(): result = supabase.table("users").select("*").execute() return result +@router.get("/users/{user_id}") +async def get_user(user_id: str): + try: + result = supabase.table("users").select("*").eq("id", user_id).execute() + + if not result.data: + raise HTTPException(status_code=404, detail="User not found") + + return result.data[0] + except HTTPException: + raise + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error fetching user: {str(e)}") + # ========== AUDIENCE INSIGHTS ROUTES ========== @router.post("/audience-insights/") async def create_audience_insights(insights: AudienceInsightsCreate): diff --git a/Backend/app/routes/pricing.py b/Backend/app/routes/pricing.py new file mode 100644 index 0000000..c5ab8f3 --- /dev/null +++ b/Backend/app/routes/pricing.py @@ -0,0 +1,336 @@ +from fastapi import APIRouter, HTTPException, Depends +from pydantic import BaseModel +from typing import Optional, List, Dict +from datetime import datetime +import os +from dotenv import load_dotenv + +from ..services.pricing_service import PricingService + +load_dotenv() + +router = APIRouter(prefix="/api/pricing", tags=["pricing"]) + +# Pydantic models +class PricingRequest(BaseModel): + creator_followers: int + creator_engagement_rate: float + content_type: str + campaign_type: str + platform: str + duration_weeks: int + exclusivity_level: str = "none" + creator_id: Optional[str] = None + brand_id: Optional[str] = None + +class PricingFeedback(BaseModel): + contract_id: str + recommended_price: float + actual_price: float + satisfaction_score: int # 1-10 + roi_achieved: float # Percentage + repeat_business: bool + feedback_notes: Optional[str] = None + +class PricingRecommendation(BaseModel): + recommended_price: float + confidence_score: float + reasoning: str + similar_contracts_used: List[Dict] + market_factors: Dict + +# Initialize pricing service +def get_pricing_service(): + return PricingService() + +@router.post("/recommendation", response_model=PricingRecommendation) +async def get_pricing_recommendation( + request: PricingRequest, + pricing_service: PricingService = Depends(get_pricing_service) +): + """ + Get AI-powered pricing recommendation based on similar contracts + """ + try: + # Validate input parameters + if request.creator_followers <= 0: + raise HTTPException(status_code=400, detail="Creator followers must be positive") + + if request.creator_engagement_rate < 0 or request.creator_engagement_rate > 100: + raise HTTPException(status_code=400, detail="Engagement rate must be between 0 and 100") + + if request.duration_weeks <= 0: + raise HTTPException(status_code=400, detail="Duration must be positive") + + # Find similar contracts + similar_contracts = pricing_service.find_similar_contracts( + creator_followers=request.creator_followers, + creator_engagement_rate=request.creator_engagement_rate, + content_type=request.content_type, + campaign_type=request.campaign_type, + platform=request.platform, + duration_weeks=request.duration_weeks, + exclusivity_level=request.exclusivity_level + ) + + # Generate price recommendation + recommendation = pricing_service.generate_price_recommendation( + similar_contracts=similar_contracts, + creator_followers=request.creator_followers, + creator_engagement_rate=request.creator_engagement_rate, + content_type=request.content_type, + campaign_type=request.campaign_type, + platform=request.platform, + duration_weeks=request.duration_weeks, + exclusivity_level=request.exclusivity_level + ) + + return recommendation + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error generating pricing recommendation: {str(e)}") + +@router.post("/feedback") +async def submit_pricing_feedback( + feedback: PricingFeedback, + pricing_service: PricingService = Depends(get_pricing_service) +): + """ + Submit feedback on pricing recommendation accuracy + """ + try: + # Validate feedback + if feedback.satisfaction_score < 1 or feedback.satisfaction_score > 10: + raise HTTPException(status_code=400, detail="Satisfaction score must be between 1 and 10") + + if feedback.roi_achieved < 0 or feedback.roi_achieved > 1000: + raise HTTPException(status_code=400, detail="ROI achieved must be between 0 and 1000") + + # Learn from the outcome + success = pricing_service.learn_from_outcome( + contract_id=feedback.contract_id, + recommended_price=feedback.recommended_price, + actual_price=feedback.actual_price, + satisfaction_score=feedback.satisfaction_score, + roi_achieved=feedback.roi_achieved, + repeat_business=feedback.repeat_business + ) + + if not success: + raise HTTPException(status_code=500, detail="Failed to process feedback") + + return { + "message": "Feedback submitted successfully", + "contract_id": feedback.contract_id, + "accuracy_score": pricing_service._calculate_accuracy_score( + feedback.recommended_price, + feedback.actual_price + ) + } + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error submitting feedback: {str(e)}") + +@router.get("/similar-contracts") +async def get_similar_contracts( + creator_followers: int, + creator_engagement_rate: float, + content_type: str, + platform: str, + campaign_type: str = "product_launch", + duration_weeks: int = 4, + exclusivity_level: str = "none", + limit: int = 10, + pricing_service: PricingService = Depends(get_pricing_service) +): + """ + Get similar contracts for analysis + """ + try: + similar_contracts = pricing_service.find_similar_contracts( + creator_followers=creator_followers, + creator_engagement_rate=creator_engagement_rate, + content_type=content_type, + campaign_type=campaign_type, + platform=platform, + duration_weeks=duration_weeks, + exclusivity_level=exclusivity_level, + limit=limit + ) + + return { + "similar_contracts": similar_contracts, + "count": len(similar_contracts), + "query_params": { + "creator_followers": creator_followers, + "creator_engagement_rate": creator_engagement_rate, + "content_type": content_type, + "campaign_type": campaign_type, + "platform": platform, + "duration_weeks": duration_weeks, + "exclusivity_level": exclusivity_level + } + } + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error finding similar contracts: {str(e)}") + +@router.get("/market-analysis") +async def get_market_analysis( + content_type: str, + platform: str, + pricing_service: PricingService = Depends(get_pricing_service) +): + """ + Get market analysis for specific content type and platform + """ + try: + # Get all contracts for the specified content type and platform + supabase_url = os.getenv("SUPABASE_URL") + supabase_key = os.getenv("SUPABASE_KEY") + + if not supabase_url or not supabase_key: + raise HTTPException(status_code=500, detail="Database configuration error") + + from supabase import create_client + supabase = create_client(supabase_url, supabase_key) + + response = supabase.table("contracts").select( + "total_budget, creator_followers, creator_engagement_rate, content_type, platform" + ).eq("content_type", content_type).eq("platform", platform).not_.is_("total_budget", "null").execute() + + contracts = response.data + + if not contracts: + return { + "content_type": content_type, + "platform": platform, + "message": "No data available for this combination", + "analysis": {} + } + + # Calculate market statistics + prices = [c.get("total_budget", 0) for c in contracts if c.get("total_budget")] + followers = [c.get("creator_followers", 0) for c in contracts if c.get("creator_followers")] + engagement_rates = [c.get("creator_engagement_rate", 0) for c in contracts if c.get("creator_engagement_rate")] + + analysis = { + "total_contracts": len(contracts), + "price_stats": { + "average": sum(prices) / len(prices) if prices else 0, + "median": sorted(prices)[len(prices)//2] if prices else 0, + "min": min(prices) if prices else 0, + "max": max(prices) if prices else 0 + }, + "follower_stats": { + "average": sum(followers) / len(followers) if followers else 0, + "median": sorted(followers)[len(followers)//2] if followers else 0, + "min": min(followers) if followers else 0, + "max": max(followers) if followers else 0 + }, + "engagement_stats": { + "average": sum(engagement_rates) / len(engagement_rates) if engagement_rates else 0, + "median": sorted(engagement_rates)[len(engagement_rates)//2] if engagement_rates else 0, + "min": min(engagement_rates) if engagement_rates else 0, + "max": max(engagement_rates) if engagement_rates else 0 + } + } + + return { + "content_type": content_type, + "platform": platform, + "analysis": analysis + } + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error analyzing market data: {str(e)}") + +@router.get("/test-db") +async def test_database_connection(): + """ + Test database connection and basic query + """ + try: + supabase_url = os.getenv("SUPABASE_URL") + supabase_key = os.getenv("SUPABASE_KEY") + + if not supabase_url or not supabase_key: + raise HTTPException(status_code=500, detail="Database configuration error") + + from supabase import create_client + supabase = create_client(supabase_url, supabase_key) + + # Simple query to test connection + response = supabase.table("contracts").select("id, content_type, platform").limit(5).execute() + + return { + "message": "Database connection successful", + "contracts_found": len(response.data), + "sample_data": response.data[:2] if response.data else [] + } + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Database connection failed: {str(e)}") + +@router.get("/learning-stats") +async def get_learning_statistics( + pricing_service: PricingService = Depends(get_pricing_service) +): + """ + Get statistics about the learning system performance + """ + try: + supabase_url = os.getenv("SUPABASE_URL") + supabase_key = os.getenv("SUPABASE_KEY") + + if not supabase_url or not supabase_key: + raise HTTPException(status_code=500, detail="Database configuration error") + + from supabase import create_client + supabase = create_client(supabase_url, supabase_key) + + # Get feedback statistics + feedback_response = supabase.table("pricing_feedback").select("*").execute() + feedback_data = feedback_response.data + + # Get contract outcome statistics + contracts_response = supabase.table("contracts").select( + "brand_satisfaction_score, roi_achieved, repeat_business" + ).not_.is_("brand_satisfaction_score", "null").execute() + contracts_data = contracts_response.data + + stats = { + "total_feedback_submissions": len(feedback_data), + "total_contracts_with_outcomes": len(contracts_data), + "average_accuracy_score": 0, + "average_satisfaction_score": 0, + "average_roi_achieved": 0, + "repeat_business_rate": 0 + } + + if feedback_data: + accuracy_scores = [f.get("price_accuracy_score", 0) for f in feedback_data] + stats["average_accuracy_score"] = sum(accuracy_scores) / len(accuracy_scores) + + if contracts_data: + satisfaction_scores = [c.get("brand_satisfaction_score", 0) for c in contracts_data if c.get("brand_satisfaction_score")] + roi_values = [c.get("roi_achieved", 0) for c in contracts_data if c.get("roi_achieved")] + repeat_business = [c.get("repeat_business", False) for c in contracts_data if c.get("repeat_business") is not None] + + if satisfaction_scores: + stats["average_satisfaction_score"] = sum(satisfaction_scores) / len(satisfaction_scores) + if roi_values: + stats["average_roi_achieved"] = sum(roi_values) / len(roi_values) + if repeat_business: + stats["repeat_business_rate"] = sum(repeat_business) / len(repeat_business) + + return { + "learning_statistics": stats, + "system_performance": { + "data_points": len(feedback_data) + len(contracts_data), + "learning_active": len(feedback_data) > 0 + } + } + + except Exception as e: + raise HTTPException(status_code=500, detail=f"Error getting learning statistics: {str(e)}") \ No newline at end of file diff --git a/Backend/app/routes/roi_analytics.py b/Backend/app/routes/roi_analytics.py new file mode 100644 index 0000000..9e8139f --- /dev/null +++ b/Backend/app/routes/roi_analytics.py @@ -0,0 +1,455 @@ +""" +ROI Analytics API Routes + +Provides endpoints for ROI calculations, trend analysis, and target comparisons. +""" + +from fastapi import APIRouter, Depends, HTTPException, status, Query +from sqlalchemy.orm import Session +from typing import List, Optional, Dict, Any +from datetime import datetime, timedelta +from decimal import Decimal +from pydantic import BaseModel + +from app.db.db import get_db +from app.models.models import User, Sponsorship +from app.services.roi_service import ROIService, ROIMetrics, ROITrend, ROITarget + + +router = APIRouter(prefix="/api/roi", tags=["roi-analytics"]) + + +# Request/Response Models +class ROIMetricsResponse(BaseModel): + campaign_id: str + total_spend: float + total_revenue: float + roi_percentage: float + cost_per_acquisition: float + conversions: int + impressions: int + reach: int + engagement_rate: float + click_through_rate: float + period_start: str + period_end: str + + +class ROITrendResponse(BaseModel): + period: str + roi_percentage: float + spend: float + revenue: float + conversions: int + date: str + + +class ROITargetResponse(BaseModel): + target_roi: float + actual_roi: float + target_cpa: Optional[float] + actual_cpa: float + target_met: bool + variance_percentage: float + + +class CampaignROISummaryResponse(BaseModel): + campaign_id: str + campaign_title: str + roi_metrics: ROIMetricsResponse + + +class PortfolioROIResponse(BaseModel): + brand_id: str + portfolio_metrics: ROIMetricsResponse + campaign_count: int + top_performing_campaigns: List[CampaignROISummaryResponse] + + +# Helper function to get current user (placeholder - replace with actual auth) +def get_current_user(db: Session = Depends(get_db)) -> User: + # TODO: Replace with actual authentication logic + # For now, return a dummy user for testing + user = db.query(User).first() + if not user: + raise HTTPException(status_code=401, detail="User not found") + return user + + +def verify_campaign_access(campaign_id: str, user_id: str, db: Session) -> bool: + """Verify that user has access to the campaign""" + campaign = db.query(Sponsorship).filter(Sponsorship.id == campaign_id).first() + if not campaign: + # Signal not found distinctly so endpoints can return 404 + raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Campaign not found") + + # Check if user is the brand owner + if campaign.brand_id == user_id: + return True + + # Check if user has applied to this sponsorship (creator access) + from app.models.models import SponsorshipApplication + application = db.query(SponsorshipApplication).filter( + SponsorshipApplication.sponsorship_id == campaign_id, + SponsorshipApplication.creator_id == user_id + ).first() + + return application is not None + + +def convert_roi_metrics_to_response(roi_metrics: ROIMetrics) -> ROIMetricsResponse: + """Convert ROIMetrics dataclass to response model""" + return ROIMetricsResponse( + campaign_id=roi_metrics.campaign_id, + total_spend=float(roi_metrics.total_spend), + total_revenue=float(roi_metrics.total_revenue), + roi_percentage=float(roi_metrics.roi_percentage), + cost_per_acquisition=float(roi_metrics.cost_per_acquisition), + conversions=roi_metrics.conversions, + impressions=roi_metrics.impressions, + reach=roi_metrics.reach, + engagement_rate=float(roi_metrics.engagement_rate), + click_through_rate=float(roi_metrics.click_through_rate), + period_start=roi_metrics.period_start.isoformat(), + period_end=roi_metrics.period_end.isoformat() + ) + + +@router.get("/campaigns/{campaign_id}", response_model=ROIMetricsResponse) +async def get_campaign_roi( + campaign_id: str, + days: int = Query(30, ge=1, le=365, description="Number of days to analyze"), + use_cache: bool = Query(True, description="Whether to use cache for faster response"), + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db) +): + """Get ROI metrics for a specific campaign with caching support""" + try: + # Verify user has access to this campaign + verify_campaign_access(campaign_id, current_user.id, db) + + # Calculate date range + end_date = datetime.now() + start_date = end_date - timedelta(days=days) + + # Get ROI metrics with caching + roi_service = ROIService(db) + roi_metrics = await roi_service.calculate_campaign_roi_async( + campaign_id, start_date, end_date, use_cache + ) + + if not roi_metrics: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail="No ROI data available for this campaign" + ) + + return convert_roi_metrics_to_response(roi_metrics) + + except HTTPException: + raise + except Exception as e: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Failed to calculate campaign ROI: {str(e)}" + ) + + +@router.get("/campaigns/{campaign_id}/trends", response_model=List[ROITrendResponse]) +async def get_campaign_roi_trends( + campaign_id: str, + period_type: str = Query("daily", pattern="^(daily|weekly|monthly)$", description="Period type for trend analysis"), + num_periods: int = Query(30, ge=1, le=365, description="Number of periods to analyze"), + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db) +): + """Get ROI trends for a campaign over time""" + try: + # Verify user has access to this campaign + verify_campaign_access(campaign_id, current_user.id, db) + + # Get ROI trends + roi_service = ROIService(db) + trends = roi_service.calculate_roi_trends(campaign_id, period_type, num_periods) + + return [ + ROITrendResponse( + period=trend.period, + roi_percentage=float(trend.roi_percentage), + spend=float(trend.spend), + revenue=float(trend.revenue), + conversions=trend.conversions, + date=trend.date.isoformat() + ) + for trend in trends + ] + + except HTTPException: + raise + except Exception as e: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Failed to calculate ROI trends: {str(e)}" + ) + + +@router.get("/campaigns/{campaign_id}/targets", response_model=ROITargetResponse) +async def compare_campaign_roi_to_targets( + campaign_id: str, + target_roi: float = Query(..., description="Target ROI percentage"), + target_cpa: Optional[float] = Query(None, description="Target cost per acquisition"), + days: int = Query(30, ge=1, le=365, description="Number of days to analyze"), + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db) +): + """Compare campaign ROI performance to targets""" + try: + # Verify user has access to this campaign + if not verify_campaign_access(campaign_id, current_user.id, db): + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="Access denied to this campaign" + ) + + # Calculate date range + end_date = datetime.now() + start_date = end_date - timedelta(days=days) + + # Compare to targets + roi_service = ROIService(db) + target_comparison = roi_service.compare_roi_to_targets( + campaign_id, + Decimal(str(target_roi)), + Decimal(str(target_cpa)) if target_cpa else None, + start_date, + end_date + ) + + if not target_comparison: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail="No ROI data available for target comparison" + ) + + return ROITargetResponse( + target_roi=float(target_comparison.target_roi), + actual_roi=float(target_comparison.actual_roi), + target_cpa=float(target_comparison.target_cpa) if target_comparison.target_cpa else None, + actual_cpa=float(target_comparison.actual_cpa), + target_met=target_comparison.target_met, + variance_percentage=float(target_comparison.variance_percentage) + ) + + except HTTPException: + raise + except Exception as e: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Failed to compare ROI to targets: {str(e)}" + ) + + +@router.get("/campaigns/summary", response_model=Dict[str, ROIMetricsResponse]) +async def get_campaigns_roi_summary( + campaign_ids: List[str] = Query(..., description="List of campaign IDs to analyze"), + days: int = Query(30, ge=1, le=365, description="Number of days to analyze"), + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db) +): + """Get ROI summary for multiple campaigns""" + try: + # Verify user has access to all campaigns + for campaign_id in campaign_ids: + verify_campaign_access(campaign_id, current_user.id, db) + + # Calculate date range + end_date = datetime.now() + start_date = end_date - timedelta(days=days) + + # Get ROI summary + roi_service = ROIService(db) + summary = roi_service.get_campaign_roi_summary(campaign_ids, start_date, end_date) + + return { + campaign_id: convert_roi_metrics_to_response(roi_metrics) + for campaign_id, roi_metrics in summary.items() + } + + except HTTPException: + raise + except Exception as e: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Failed to get campaigns ROI summary: {str(e)}" + ) + + +@router.get("/portfolio/{brand_id}", response_model=PortfolioROIResponse) +async def get_brand_portfolio_roi( + brand_id: str, + days: int = Query(30, ge=1, le=365, description="Number of days to analyze"), + include_top_campaigns: int = Query(5, ge=1, le=20, description="Number of top campaigns to include"), + use_cache: bool = Query(True, description="Whether to use cache for faster response"), + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db) +): + """Get portfolio ROI for all campaigns of a brand with caching support""" + try: + # Verify user is the brand owner or has appropriate access + if current_user.id != brand_id and current_user.role != 'admin': + raise HTTPException( + status_code=status.HTTP_403_FORBIDDEN, + detail="Access denied to this brand's portfolio" + ) + + # Calculate date range + end_date = datetime.now() + start_date = end_date - timedelta(days=days) + + # Get portfolio ROI with caching + roi_service = ROIService(db) + portfolio_metrics = await roi_service.calculate_portfolio_roi_async( + brand_id, start_date, end_date, use_cache + ) + + if not portfolio_metrics: + raise HTTPException( + status_code=status.HTTP_404_NOT_FOUND, + detail="No portfolio data available for this brand" + ) + + # Get individual campaign ROI for top performers + campaigns = db.query(Sponsorship).filter(Sponsorship.brand_id == brand_id).all() + campaign_ids = [c.id for c in campaigns] + + # Use optimized summary query + from app.services.database_optimization_service import db_optimization_service + campaign_summary_data = db_optimization_service.get_aggregated_campaign_summary( + db, campaign_ids, start_date, end_date + ) + + # Sort campaigns by ROI and get top performers + sorted_campaigns = sorted( + campaign_summary_data.items(), + key=lambda x: (x[1]['total_revenue'] / max(1, x[1]['total_impressions'])) * 100, # Simple ROI proxy + reverse=True + )[:include_top_campaigns] + + top_campaigns = [] + for campaign_id, summary_data in sorted_campaigns: + campaign = next((c for c in campaigns if c.id == campaign_id), None) + if campaign: + # Convert summary to ROI metrics format + roi_metrics = await roi_service.calculate_campaign_roi_async( + campaign_id, start_date, end_date, use_cache + ) + if roi_metrics: + top_campaigns.append(CampaignROISummaryResponse( + campaign_id=campaign_id, + campaign_title=campaign.title, + roi_metrics=convert_roi_metrics_to_response(roi_metrics) + )) + + return PortfolioROIResponse( + brand_id=brand_id, + portfolio_metrics=convert_roi_metrics_to_response(portfolio_metrics), + campaign_count=len(campaigns), + top_performing_campaigns=top_campaigns + ) + + except HTTPException: + raise + except Exception as e: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Failed to get portfolio ROI: {str(e)}" + ) + + +@router.get("/benchmarks") +async def get_roi_benchmarks( + industry: Optional[str] = Query(None, description="Industry for benchmarks"), + platform: Optional[str] = Query(None, description="Platform for benchmarks"), + current_user: User = Depends(get_current_user), + db: Session = Depends(get_db) +): + """Get ROI benchmarks for comparison""" + try: + # This would typically come from a benchmarks database or external service + # For now, return industry standard benchmarks + benchmarks = { + "general": { + "average_roi": 4.0, # 400% ROI + "good_roi": 6.0, # 600% ROI + "excellent_roi": 10.0, # 1000% ROI + "average_cpa": 50.0, + "average_ctr": 2.5, + "average_engagement_rate": 3.5 + }, + "by_industry": { + "fashion": { + "average_roi": 5.2, + "average_cpa": 45.0, + "average_ctr": 3.1, + "average_engagement_rate": 4.2 + }, + "technology": { + "average_roi": 3.8, + "average_cpa": 65.0, + "average_ctr": 2.1, + "average_engagement_rate": 2.8 + }, + "food_beverage": { + "average_roi": 4.5, + "average_cpa": 40.0, + "average_ctr": 2.8, + "average_engagement_rate": 5.1 + } + }, + "by_platform": { + "instagram": { + "average_roi": 4.2, + "average_cpa": 48.0, + "average_ctr": 2.7, + "average_engagement_rate": 4.1 + }, + "youtube": { + "average_roi": 3.9, + "average_cpa": 55.0, + "average_ctr": 2.3, + "average_engagement_rate": 3.2 + }, + "tiktok": { + "average_roi": 5.8, + "average_cpa": 35.0, + "average_ctr": 3.5, + "average_engagement_rate": 6.2 + } + } + } + + # Filter by industry or platform if specified + if industry and industry in benchmarks["by_industry"]: + return { + "industry": industry, + "benchmarks": benchmarks["by_industry"][industry], + "general_benchmarks": benchmarks["general"] + } + + if platform and platform in benchmarks["by_platform"]: + return { + "platform": platform, + "benchmarks": benchmarks["by_platform"][platform], + "general_benchmarks": benchmarks["general"] + } + + return { + "all_benchmarks": benchmarks, + "note": "Benchmarks are based on industry averages and may vary by specific use case" + } + + except Exception as e: + raise HTTPException( + status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, + detail=f"Failed to get ROI benchmarks: {str(e)}" + ) \ No newline at end of file diff --git a/Backend/app/schemas/schema.py b/Backend/app/schemas/schema.py index 7389488..e1b2d75 100644 --- a/Backend/app/schemas/schema.py +++ b/Backend/app/schemas/schema.py @@ -1,5 +1,5 @@ from pydantic import BaseModel -from typing import Optional, Dict +from typing import Optional, Dict, List from datetime import datetime class UserCreate(BaseModel): @@ -51,3 +51,192 @@ class CollaborationCreate(BaseModel): creator_1_id: str creator_2_id: str collaboration_details: str + + +# ============================================================================ +# BRAND DASHBOARD SCHEMAS +# ============================================================================ + +# Brand Profile Schemas +class BrandProfileCreate(BaseModel): + user_id: str + company_name: Optional[str] = None + website: Optional[str] = None + industry: Optional[str] = None + contact_person: Optional[str] = None + contact_email: Optional[str] = None + +class BrandProfileUpdate(BaseModel): + company_name: Optional[str] = None + website: Optional[str] = None + industry: Optional[str] = None + contact_person: Optional[str] = None + contact_email: Optional[str] = None + +class BrandProfileResponse(BaseModel): + id: str + user_id: str + company_name: Optional[str] = None + website: Optional[str] = None + industry: Optional[str] = None + contact_person: Optional[str] = None + contact_email: Optional[str] = None + created_at: datetime + + class Config: + from_attributes = True + + +# Campaign Metrics Schemas +class CampaignMetricsCreate(BaseModel): + campaign_id: str + impressions: Optional[int] = None + clicks: Optional[int] = None + conversions: Optional[int] = None + revenue: Optional[float] = None + engagement_rate: Optional[float] = None + +class CampaignMetricsResponse(BaseModel): + id: str + campaign_id: str + impressions: Optional[int] = None + clicks: Optional[int] = None + conversions: Optional[int] = None + revenue: Optional[float] = None + engagement_rate: Optional[float] = None + recorded_at: datetime + + class Config: + from_attributes = True + + +# Contract Schemas +class ContractCreate(BaseModel): + sponsorship_id: str + creator_id: str + brand_id: str + contract_url: Optional[str] = None + status: str = "draft" + +class ContractUpdate(BaseModel): + contract_url: Optional[str] = None + status: Optional[str] = None + +class ContractResponse(BaseModel): + id: str + sponsorship_id: str + creator_id: str + brand_id: str + contract_url: Optional[str] = None + status: str + created_at: datetime + + class Config: + from_attributes = True + + +# Creator Match Schemas +class CreatorMatchResponse(BaseModel): + id: str + brand_id: str + creator_id: str + match_score: Optional[float] = None + matched_at: datetime + + class Config: + from_attributes = True + + +# Dashboard Analytics Schemas +class DashboardOverviewResponse(BaseModel): + total_campaigns: int + active_campaigns: int + total_revenue: float + total_creators_matched: int + recent_activity: list + +class CampaignAnalyticsResponse(BaseModel): + campaign_id: str + campaign_title: str + impressions: int + clicks: int + conversions: int + revenue: float + engagement_rate: float + roi: float + +class CreatorMatchAnalyticsResponse(BaseModel): + creator_id: str + creator_name: str + match_score: float + audience_overlap: float + engagement_rate: float + estimated_reach: int + + +# ============================================================================ +# ADDITIONAL SCHEMAS FOR EXISTING TABLES +# ============================================================================ + +# Application Management Schemas +class SponsorshipApplicationResponse(BaseModel): + id: str + creator_id: str + sponsorship_id: str + post_id: Optional[str] = None + proposal: str + status: str + applied_at: datetime + creator: Optional[Dict] = None # From users table + campaign: Optional[Dict] = None # From sponsorships table + + class Config: + from_attributes = True + +class ApplicationUpdateRequest(BaseModel): + status: str # "accepted", "rejected", "pending" + notes: Optional[str] = None + +class ApplicationSummaryResponse(BaseModel): + total_applications: int + pending_applications: int + accepted_applications: int + rejected_applications: int + applications_by_campaign: Dict[str, int] + recent_applications: List[Dict] + + +# Payment Management Schemas +class PaymentResponse(BaseModel): + id: str + creator_id: str + brand_id: str + sponsorship_id: str + amount: float + status: str + transaction_date: datetime + creator: Optional[Dict] = None # From users table + campaign: Optional[Dict] = None # From sponsorships table + + class Config: + from_attributes = True + +class PaymentStatusUpdate(BaseModel): + status: str # "pending", "completed", "failed", "cancelled" + +class PaymentAnalyticsResponse(BaseModel): + total_payments: int + completed_payments: int + pending_payments: int + total_amount: float + average_payment: float + payments_by_month: Dict[str, float] + + +# Campaign Metrics Management Schemas +class CampaignMetricsUpdate(BaseModel): + impressions: Optional[int] = None + clicks: Optional[int] = None + conversions: Optional[int] = None + revenue: Optional[float] = None + engagement_rate: Optional[float] = None diff --git a/Backend/app/services/ai_router.py b/Backend/app/services/ai_router.py new file mode 100644 index 0000000..c5c8492 --- /dev/null +++ b/Backend/app/services/ai_router.py @@ -0,0 +1,343 @@ +import os +import json +import logging +from datetime import datetime +from typing import Dict, List, Optional, Any +from groq import Groq +from fastapi import HTTPException +from dotenv import load_dotenv + +# Load environment variables +load_dotenv() + +# Setup logging +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +class AIRouter: + def __init__(self): + """Initialize AI Router with Groq client""" + self.groq_api_key = os.getenv("GROQ_API_KEY") + if not self.groq_api_key: + raise ValueError("GROQ_API_KEY environment variable is required") + + self.client = Groq(api_key=self.groq_api_key) + + # Available API routes and their descriptions + self.available_routes = { + "dashboard_overview": { + "endpoint": "/api/brand/dashboard/overview", + "description": "Get dashboard overview with key metrics (total campaigns, revenue, creator matches, recent activity)", + "parameters": ["brand_id"], + "method": "GET" + }, + "brand_profile": { + "endpoint": "/api/brand/profile/{user_id}", + "description": "Get or update brand profile information", + "parameters": ["user_id"], + "method": "GET/PUT" + }, + "campaigns": { + "endpoint": "/api/brand/campaigns", + "description": "Manage campaigns (list, create, update, delete)", + "parameters": ["brand_id", "campaign_id (optional)"], + "method": "GET/POST/PUT/DELETE" + }, + "creator_matches": { + "endpoint": "/api/brand/creators/matches", + "description": "Get AI-matched creators for the brand", + "parameters": ["brand_id"], + "method": "GET" + }, + "creator_search": { + "endpoint": "/api/brand/creators/search", + "description": "Search for creators based on criteria (industry, engagement, location)", + "parameters": ["brand_id", "industry (optional)", "min_engagement (optional)", "location (optional)"], + "method": "GET" + }, + "creator_profile": { + "endpoint": "/api/brand/creators/{creator_id}/profile", + "description": "Get detailed creator profile with insights and posts", + "parameters": ["creator_id", "brand_id"], + "method": "GET" + }, + "analytics_performance": { + "endpoint": "/api/brand/analytics/performance", + "description": "Get campaign performance analytics and ROI", + "parameters": ["brand_id"], + "method": "GET" + }, + "analytics_revenue": { + "endpoint": "/api/brand/analytics/revenue", + "description": "Get revenue analytics and payment statistics", + "parameters": ["brand_id"], + "method": "GET" + }, + "contracts": { + "endpoint": "/api/brand/contracts", + "description": "Manage contracts (list, create, update status)", + "parameters": ["brand_id", "contract_id (optional)"], + "method": "GET/POST/PUT" + } + } + + def create_system_prompt(self) -> str: + """Create the system prompt for the LLM""" + routes_info = "\n".join([ + f"- {route_name}: {info['description']} (Parameters: {', '.join(info['parameters'])})" + for route_name, info in self.available_routes.items() + ]) + + return f"""You are an intelligent AI assistant for a brand dashboard. Your job is to understand user queries and route them to the appropriate API endpoints. + +Available API Routes: +{routes_info} + +IMPORTANT: You MUST respond with valid JSON only. No additional text before or after the JSON. + +Your tasks: +1. Understand the user's intent from their natural language query +2. Identify which API route(s) should be called +3. Extract required parameters from the query +4. If information is missing, ask follow-up questions +5. Return a structured response with the action to take + +Response format (MUST be valid JSON): +{{ + "intent": "what the user wants to do", + "route": "route_name or null if follow_up_needed", + "parameters": {{"param_name": "value"}}, + "follow_up_needed": true/false, + "follow_up_question": "question to ask if more info needed", + "explanation": "brief explanation of what you understood" +}} + +Examples of valid responses: + +Query: "Show me my dashboard" +Response: {{"intent": "View dashboard overview", "route": "dashboard_overview", "parameters": {{}}, "follow_up_needed": false, "follow_up_question": null, "explanation": "User wants to see dashboard overview with metrics"}} + +Query: "Find creators in tech" +Response: {{"intent": "Search for creators", "route": "creator_search", "parameters": {{"industry": "tech"}}, "follow_up_needed": false, "follow_up_question": null, "explanation": "User wants to find creators in tech industry"}} + +Query: "Show campaigns" +Response: {{"intent": "List campaigns", "route": "campaigns", "parameters": {{}}, "follow_up_needed": false, "follow_up_question": null, "explanation": "User wants to see their campaigns"}} + +Query: "What's my revenue?" +Response: {{"intent": "View revenue analytics", "route": "analytics_revenue", "parameters": {{}}, "follow_up_needed": false, "follow_up_question": null, "explanation": "User wants to see revenue analytics"}} + +Remember: Always return valid JSON, no extra text.""" + + async def process_query(self, query: str, brand_id: str = None) -> Dict[str, Any]: + """Process a natural language query and return routing information""" + try: + # Create the conversation with system prompt + messages = [ + {"role": "system", "content": self.create_system_prompt()}, + {"role": "user", "content": f"User query: {query}"} + ] + + # Add brand_id context if available + if brand_id: + messages.append({ + "role": "system", + "content": f"Note: The user's brand_id is {brand_id}. Use this for any endpoints that require it." + }) + + # Call Groq LLM with lower temperature for more consistent responses + response = self.client.chat.completions.create( + model="moonshotai/kimi-k2-instruct", # Updated to Kimi K2 instruct + messages=messages, + temperature=0.1, # Lower temperature for more consistent JSON output + max_tokens=1024 # Updated max tokens + ) + + # Parse the response + llm_response = response.choices[0].message.content.strip() + + # Clean the response and try to parse JSON with retry logic + parsed_response = self._parse_json_with_retry(llm_response, query) + + # Validate and enhance the response + enhanced_response = self._enhance_response(parsed_response, brand_id, query) + + logger.info(f"AI Router processed query: '{query}' -> {enhanced_response['intent']}") + return enhanced_response + + except Exception as e: + logger.error(f"Error processing query with AI Router: {e}") + raise HTTPException(status_code=500, detail="AI processing error") + + def _enhance_response(self, response: Dict[str, Any], brand_id: str, original_query: str) -> Dict[str, Any]: + """Enhance the LLM response with additional context and validation""" + + # Add brand_id to parameters if not present and route needs it + if brand_id and response.get("route"): + route_info = self.available_routes.get(response["route"]) + if route_info and "brand_id" in route_info["parameters"]: + if "parameters" not in response: + response["parameters"] = {} + if "brand_id" not in response["parameters"]: + response["parameters"]["brand_id"] = str(brand_id) # Ensure brand_id is string + + # Validate route exists + if response.get("route") and response["route"] not in self.available_routes: + response["route"] = None + response["follow_up_needed"] = True + response["follow_up_question"] = f"I don't recognize that action. Available actions include: {', '.join(self.available_routes.keys())}" + + # Ensure parameter types are correct (brand_id should be string) + if "parameters" in response: + if "brand_id" in response["parameters"]: + response["parameters"]["brand_id"] = str(response["parameters"]["brand_id"]) + + # Add metadata + response["original_query"] = original_query + response["timestamp"] = str(datetime.now()) + + return response + + def _clean_llm_response(self, response: str) -> str: + """Clean LLM response to extract valid JSON""" + # Remove markdown code blocks + if "```json" in response: + start = response.find("```json") + 7 + end = response.find("```", start) + if end != -1: + response = response[start:end].strip() + elif "```" in response: + start = response.find("```") + 3 + end = response.find("```", start) + if end != -1: + response = response[start:end].strip() + + # Remove any text before the first { + if "{" in response: + response = response[response.find("{"):] + + # Remove any text after the last } + if "}" in response: + response = response[:response.rfind("}") + 1] + + return response.strip() + + def _parse_json_with_retry(self, llm_response: str, original_query: str) -> Dict[str, Any]: + """Parse JSON with multiple fallback strategies""" + # Strategy 1: Try direct JSON parsing + try: + return json.loads(llm_response) + except json.JSONDecodeError: + pass + + # Strategy 2: Clean and try again + cleaned_response = self._clean_llm_response(llm_response) + try: + return json.loads(cleaned_response) + except json.JSONDecodeError: + pass + + # Strategy 3: Try to extract JSON from the response + try: + # Look for JSON-like structure + import re + json_pattern = r'\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}' + matches = re.findall(json_pattern, llm_response) + if matches: + return json.loads(matches[0]) + except (json.JSONDecodeError, IndexError): + pass + + # Strategy 4: Create a fallback response based on simple keyword matching + fallback_response = self._create_fallback_response(original_query) + logger.warning(f"Failed to parse LLM response, using fallback: {llm_response[:100]}...") + return fallback_response + + def _create_fallback_response(self, query: str) -> Dict[str, Any]: + """Create a fallback response based on keyword matching""" + query_lower = query.lower() + + # Simple keyword matching + if any(word in query_lower for word in ["dashboard", "overview", "summary"]): + return { + "intent": "View dashboard overview", + "route": "dashboard_overview", + "parameters": {}, + "follow_up_needed": False, + "follow_up_question": None, + "explanation": "User wants to see dashboard overview" + } + elif any(word in query_lower for word in ["campaign", "campaigns"]): + return { + "intent": "List campaigns", + "route": "campaigns", + "parameters": {}, + "follow_up_needed": False, + "follow_up_question": None, + "explanation": "User wants to see their campaigns" + } + elif any(word in query_lower for word in ["creator", "creators", "influencer"]): + if any(word in query_lower for word in ["search", "find", "look"]): + return { + "intent": "Search for creators", + "route": "creator_search", + "parameters": {}, + "follow_up_needed": False, + "follow_up_question": None, + "explanation": "User wants to search for creators" + } + else: + return { + "intent": "View creator matches", + "route": "creator_matches", + "parameters": {}, + "follow_up_needed": False, + "follow_up_question": None, + "explanation": "User wants to see creator matches" + } + elif any(word in query_lower for word in ["revenue", "money", "earnings", "income"]): + return { + "intent": "View revenue analytics", + "route": "analytics_revenue", + "parameters": {}, + "follow_up_needed": False, + "follow_up_question": None, + "explanation": "User wants to see revenue analytics" + } + elif any(word in query_lower for word in ["performance", "analytics", "metrics"]): + return { + "intent": "View performance analytics", + "route": "analytics_performance", + "parameters": {}, + "follow_up_needed": False, + "follow_up_question": None, + "explanation": "User wants to see performance analytics" + } + elif any(word in query_lower for word in ["contract", "contracts"]): + return { + "intent": "View contracts", + "route": "contracts", + "parameters": {}, + "follow_up_needed": False, + "follow_up_question": None, + "explanation": "User wants to see their contracts" + } + else: + return { + "intent": "unknown", + "route": None, + "parameters": {}, + "follow_up_needed": True, + "follow_up_question": "I didn't understand your request. Could you please rephrase it?", + "explanation": "Failed to parse LLM response, please try again with different wording" + } + + def get_route_info(self, route_name: str) -> Optional[Dict[str, Any]]: + """Get information about a specific route""" + return self.available_routes.get(route_name) + + def list_available_routes(self) -> Dict[str, Any]: + """List all available routes for debugging""" + return self.available_routes + +# Global instance +ai_router = AIRouter() \ No newline at end of file diff --git a/Backend/app/services/ai_services.py b/Backend/app/services/ai_services.py index 30482d3..b66e0af 100644 --- a/Backend/app/services/ai_services.py +++ b/Backend/app/services/ai_services.py @@ -19,7 +19,7 @@ def query_sponsorship_client(info): prompt = f"Extract key details about sponsorship and client interactions from the following:\n\n{info}\n\nRespond in JSON with 'sponsorship_details' and 'client_interaction_summary'." headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"} - payload = {"model": "llama3-8b-8192", "messages": [{"role": "user", "content": prompt}], "temperature": 0} + payload = {"model": "moonshotai/kimi-k2-instruct", "messages": [{"role": "user", "content": prompt}], "temperature": 0.6, "max_completion_tokens": 1024} try: response = requests.post(CHATGROQ_API_URL_CHAT, json=payload, headers=headers) diff --git a/Backend/app/services/data_collectors.py b/Backend/app/services/data_collectors.py new file mode 100644 index 0000000..3f38715 --- /dev/null +++ b/Backend/app/services/data_collectors.py @@ -0,0 +1,368 @@ +import requests +from typing import Dict, Optional, List, Any +from datetime import datetime, timedelta +from sqlalchemy.orm import Session + +from app.models.models import UserSocialToken, ContractContentMapping, ContentAnalytics +from app.services.oauth_service import oauth_service +from app.services.error_handling_service import error_handling_service + + +class RawMetrics: + """Data class for raw metrics from social platforms""" + def __init__(self, platform: str, content_id: str, metrics: Dict[str, Any], + demographics: Dict[str, Any] = None, collected_at: datetime = None): + self.platform = platform + self.content_id = content_id + self.metrics = metrics + self.demographics = demographics or {} + self.collected_at = collected_at or datetime.utcnow() + + +class InstagramDataCollector: + """Collector for Instagram content analytics using Instagram Basic Display API""" + + def __init__(self): + self.base_url = "https://graph.instagram.com" + + def collect_content_metrics(self, content_id: str, user_token: UserSocialToken) -> Optional[RawMetrics]: + """ + Collect metrics for specific Instagram content + + Args: + content_id: Instagram media ID + user_token: User's Instagram access token + + Returns: + RawMetrics object if successful, None otherwise + """ + try: + # Check if token is still valid + if not self._validate_token(user_token): + return None + + # Get media insights (requires Instagram Business account) + insights_url = f"{self.base_url}/{content_id}/insights" + insights_params = { + 'metric': 'impressions,reach,likes,comments,shares,saves', + 'access_token': user_token.access_token + } + + # Get basic media info first + media_url = f"{self.base_url}/{content_id}" + media_params = { + 'fields': 'id,media_type,caption,timestamp,like_count,comments_count', + 'access_token': user_token.access_token + } + + media_response = requests.get(media_url, params=media_params) + media_response.raise_for_status() + media_data = media_response.json() + + # Try to get insights (may fail for personal accounts) + insights_data = {} + try: + insights_response = requests.get(insights_url, params=insights_params) + if insights_response.status_code == 200: + insights_result = insights_response.json() + for insight in insights_result.get('data', []): + insights_data[insight['name']] = insight.get('values', [{}])[0].get('value', 0) + except requests.exceptions.RequestException: + # Insights not available for personal accounts + pass + + # Compile metrics + metrics = { + 'impressions': insights_data.get('impressions', 0), + 'reach': insights_data.get('reach', 0), + 'likes': media_data.get('like_count', 0), + 'comments': media_data.get('comments_count', 0), + 'shares': insights_data.get('shares', 0), + 'saves': insights_data.get('saves', 0), + 'engagement_rate': self._calculate_engagement_rate( + media_data.get('like_count', 0) + media_data.get('comments_count', 0), + insights_data.get('reach', 1) + ) + } + + return RawMetrics( + platform='instagram', + content_id=content_id, + metrics=metrics, + collected_at=datetime.utcnow() + ) + + except requests.exceptions.RequestException as e: + error = error_handling_service.handle_api_error(e, 'instagram', user_token.user_id, content_id) + error_handling_service.log_error(error) + return None + except Exception as e: + error = error_handling_service.handle_api_error(e, 'instagram', user_token.user_id, content_id) + error_handling_service.log_error(error) + return None + + def collect_user_demographics(self, user_token: UserSocialToken) -> Optional[Dict[str, Any]]: + """ + Collect user's audience demographics (requires Instagram Business account) + + Args: + user_token: User's Instagram access token + + Returns: + Demographics data if available, None otherwise + """ + try: + # This requires Instagram Business API which needs additional setup + # For now, return empty demographics + return {} + + except Exception as e: + print(f"Error collecting Instagram demographics: {e}") + return {} + + def _validate_token(self, user_token: UserSocialToken) -> bool: + """Validate Instagram access token""" + try: + url = f"{self.base_url}/me" + params = {'access_token': user_token.access_token} + + response = requests.get(url, params=params) + return response.status_code == 200 + + except requests.exceptions.RequestException: + return False + + def _calculate_engagement_rate(self, total_engagements: int, reach: int) -> float: + """Calculate engagement rate""" + if reach == 0: + return 0.0 + return round((total_engagements / reach) * 100, 4) + + +class YouTubeDataCollector: + """Collector for YouTube video analytics using YouTube Data API v3 and YouTube Analytics API""" + + def __init__(self): + self.data_api_url = "https://www.googleapis.com/youtube/v3" + self.analytics_api_url = "https://youtubeanalytics.googleapis.com/v2" + + def collect_content_metrics(self, content_id: str, user_token: UserSocialToken) -> Optional[RawMetrics]: + """ + Collect metrics for specific YouTube video + + Args: + content_id: YouTube video ID + user_token: User's YouTube access token + + Returns: + RawMetrics object if successful, None otherwise + """ + try: + # Check if token is valid and refresh if needed + if not self._ensure_valid_token(user_token): + return None + + # Get video statistics from YouTube Data API + video_url = f"{self.data_api_url}/videos" + video_params = { + 'part': 'statistics,snippet', + 'id': content_id, + 'access_token': user_token.access_token + } + + video_response = requests.get(video_url, params=video_params) + video_response.raise_for_status() + video_data = video_response.json() + + if not video_data.get('items'): + return None + + video_info = video_data['items'][0] + statistics = video_info.get('statistics', {}) + snippet = video_info.get('snippet', {}) + + # Get analytics data from YouTube Analytics API + analytics_metrics = self._get_video_analytics(content_id, user_token) + + # Compile metrics + metrics = { + 'impressions': analytics_metrics.get('impressions', 0), + 'reach': int(statistics.get('viewCount', 0)), # Views as reach proxy + 'likes': int(statistics.get('likeCount', 0)), + 'comments': int(statistics.get('commentCount', 0)), + 'shares': analytics_metrics.get('shares', 0), + 'clicks': analytics_metrics.get('clicks', 0), + 'engagement_rate': self._calculate_engagement_rate( + int(statistics.get('likeCount', 0)) + int(statistics.get('commentCount', 0)), + int(statistics.get('viewCount', 1)) + ) + } + + # Get demographics if available + demographics = self._get_video_demographics(content_id, user_token) + + return RawMetrics( + platform='youtube', + content_id=content_id, + metrics=metrics, + demographics=demographics, + collected_at=datetime.utcnow() + ) + + except requests.exceptions.RequestException as e: + error = error_handling_service.handle_api_error(e, 'youtube', user_token.user_id, content_id) + error_handling_service.log_error(error) + return None + except Exception as e: + error = error_handling_service.handle_api_error(e, 'youtube', user_token.user_id, content_id) + error_handling_service.log_error(error) + return None + + def _get_video_analytics(self, video_id: str, user_token: UserSocialToken) -> Dict[str, Any]: + """Get detailed analytics for a video""" + try: + # Calculate date range (last 30 days) + end_date = datetime.now().strftime('%Y-%m-%d') + start_date = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d') + + analytics_url = f"{self.analytics_api_url}/reports" + analytics_params = { + 'ids': f'channel=={user_token.platform_user_id}', + 'startDate': start_date, + 'endDate': end_date, + 'metrics': 'views,impressions,clicks,shares', + 'filters': f'video=={video_id}', + 'access_token': user_token.access_token + } + + response = requests.get(analytics_url, params=analytics_params) + response.raise_for_status() + + data = response.json() + rows = data.get('rows', []) + + if rows: + row = rows[0] + return { + 'views': row[0] if len(row) > 0 else 0, + 'impressions': row[1] if len(row) > 1 else 0, + 'clicks': row[2] if len(row) > 2 else 0, + 'shares': row[3] if len(row) > 3 else 0 + } + + return {} + + except requests.exceptions.RequestException as e: + print(f"YouTube Analytics API error: {e}") + return {} + + def _get_video_demographics(self, video_id: str, user_token: UserSocialToken) -> Dict[str, Any]: + """Get demographic data for a video""" + try: + # Calculate date range (last 30 days) + end_date = datetime.now().strftime('%Y-%m-%d') + start_date = (datetime.now() - timedelta(days=30)).strftime('%Y-%m-%d') + + demographics = {} + + # Get age and gender demographics + demo_url = f"{self.analytics_api_url}/reports" + demo_params = { + 'ids': f'channel=={user_token.platform_user_id}', + 'startDate': start_date, + 'endDate': end_date, + 'metrics': 'viewerPercentage', + 'dimensions': 'ageGroup,gender', + 'filters': f'video=={video_id}', + 'access_token': user_token.access_token + } + + response = requests.get(demo_url, params=demo_params) + if response.status_code == 200: + data = response.json() + rows = data.get('rows', []) + + age_groups = {} + for row in rows: + if len(row) >= 3: + age_group = row[0] + percentage = row[2] + age_groups[age_group] = percentage + + demographics['ageGroups'] = age_groups + + # Get geographic demographics + geo_params = { + 'ids': f'channel=={user_token.platform_user_id}', + 'startDate': start_date, + 'endDate': end_date, + 'metrics': 'viewerPercentage', + 'dimensions': 'country', + 'filters': f'video=={video_id}', + 'sort': '-viewerPercentage', + 'maxResults': 10, + 'access_token': user_token.access_token + } + + geo_response = requests.get(demo_url, params=geo_params) + if geo_response.status_code == 200: + geo_data = geo_response.json() + geo_rows = geo_data.get('rows', []) + + locations = {} + for row in geo_rows: + if len(row) >= 2: + country = row[0] + percentage = row[1] + locations[country] = percentage + + demographics['locations'] = locations + + return demographics + + except requests.exceptions.RequestException as e: + print(f"YouTube demographics API error: {e}") + return {} + + def _ensure_valid_token(self, user_token: UserSocialToken) -> bool: + """Ensure token is valid and refresh if needed""" + try: + # Check if token is expired + if user_token.token_expires_at and user_token.token_expires_at <= datetime.utcnow(): + # Try to refresh token + from app.db.db import get_db + db = next(get_db()) + success = oauth_service.refresh_youtube_token(user_token, db) + db.close() + return success + + return True + + except Exception as e: + print(f"Error ensuring valid token: {e}") + return False + + def _calculate_engagement_rate(self, total_engagements: int, views: int) -> float: + """Calculate engagement rate for YouTube""" + if views == 0: + return 0.0 + return round((total_engagements / views) * 100, 4) + + +class DataCollectorFactory: + """Factory for creating appropriate data collectors""" + + @staticmethod + def get_collector(platform: str): + """Get data collector for specified platform""" + if platform == 'instagram': + return InstagramDataCollector() + elif platform == 'youtube': + return YouTubeDataCollector() + else: + raise ValueError(f"Unsupported platform: {platform}") + + +# Global instances +instagram_collector = InstagramDataCollector() +youtube_collector = YouTubeDataCollector() \ No newline at end of file diff --git a/Backend/app/services/data_ingestion_service.py b/Backend/app/services/data_ingestion_service.py new file mode 100644 index 0000000..a67adce --- /dev/null +++ b/Backend/app/services/data_ingestion_service.py @@ -0,0 +1,418 @@ +from typing import Dict, List, Optional, Tuple +from datetime import datetime, timedelta +from sqlalchemy.orm import Session +from sqlalchemy import and_ + +from app.models.models import ( + ContractContentMapping, ContentAnalytics, UserSocialToken, User +) +from app.services.data_collectors import DataCollectorFactory, RawMetrics +from app.services.metrics_normalizer import metrics_normalizer, NormalizedMetrics +from app.services.oauth_service import oauth_service + + +class DataIngestionService: + """Service for orchestrating data collection and ingestion from social platforms""" + + def __init__(self): + self.rate_limits = { + 'instagram': { + 'requests_per_hour': 200, + 'requests_per_day': 4800 + }, + 'youtube': { + 'requests_per_hour': 10000, + 'requests_per_day': 1000000 + } + } + + # Track API usage (in production, this should use Redis or database) + self.usage_tracker = {} + + def sync_content_data(self, content_mapping_id: str, db: Session, force_refresh: bool = False) -> Tuple[bool, str]: + """ + Sync analytics data for a specific piece of linked content + + Args: + content_mapping_id: ID of the content mapping to sync + db: Database session + force_refresh: Whether to force refresh even if recently synced + + Returns: + Tuple of (success, message) + """ + try: + # Get content mapping + content_mapping = db.query(ContractContentMapping).filter( + ContractContentMapping.id == content_mapping_id, + ContractContentMapping.is_active == True + ).first() + + if not content_mapping: + return False, "Content mapping not found" + + # Check if we need to sync (avoid too frequent syncing) + if not force_refresh and self._is_recently_synced(content_mapping, db): + return True, "Content data is up to date" + + # Get user's social token + user_token = db.query(UserSocialToken).filter( + UserSocialToken.user_id == content_mapping.user_id, + UserSocialToken.platform == content_mapping.platform, + UserSocialToken.is_active == True + ).first() + + if not user_token: + return False, f"No active {content_mapping.platform} token found" + + # Check rate limits + if not self._check_rate_limit(content_mapping.platform, content_mapping.user_id): + return False, "Rate limit exceeded, please try again later" + + # Collect data using appropriate collector + collector = DataCollectorFactory.get_collector(content_mapping.platform) + raw_metrics = collector.collect_content_metrics(content_mapping.content_id, user_token) + + if not raw_metrics: + return False, "Failed to collect metrics from platform" + + # Normalize metrics + normalized_metrics = metrics_normalizer.normalize_metrics(raw_metrics) + + # Store in database + success = self._store_content_analytics(content_mapping, normalized_metrics, db) + + if success: + # Update usage tracker + self._update_usage_tracker(content_mapping.platform, content_mapping.user_id) + + # Trigger cache invalidation for real-time updates + try: + from app.services.cache_invalidation_service import cache_invalidation_service + import asyncio + + # Check if there's a running event loop + try: + loop = asyncio.get_running_loop() + # Run cache invalidation in background + asyncio.create_task( + cache_invalidation_service.invalidate_related_data( + db, 'content', content_mapping_id + ) + ) + except RuntimeError: + # No running event loop, skip cache invalidation + print("Warning: No running event loop for cache invalidation") + except Exception as e: + print(f"Warning: Cache invalidation failed: {e}") + + return True, "Content data synced successfully" + else: + return False, "Failed to store analytics data" + + except Exception as e: + return False, f"Error syncing content data: {str(e)}" + + def sync_contract_content(self, contract_id: str, db: Session) -> Tuple[bool, str, Dict]: + """ + Sync analytics data for all content linked to a contract + + Args: + contract_id: ID of the contract + db: Database session + + Returns: + Tuple of (success, message, results_summary) + """ + try: + # Get all active content mappings for the contract + content_mappings = db.query(ContractContentMapping).filter( + ContractContentMapping.contract_id == contract_id, + ContractContentMapping.is_active == True + ).all() + + if not content_mappings: + return True, "No content linked to this contract", {} + + results = { + 'total': len(content_mappings), + 'successful': 0, + 'failed': 0, + 'skipped': 0, + 'errors': [] + } + + for mapping in content_mappings: + success, message = self.sync_content_data(mapping.id, db) + + if success: + if "up to date" in message: + results['skipped'] += 1 + else: + results['successful'] += 1 + else: + results['failed'] += 1 + results['errors'].append({ + 'content_id': mapping.content_id, + 'platform': mapping.platform, + 'error': message + }) + + overall_success = results['failed'] == 0 + summary_message = f"Synced {results['successful']} items, skipped {results['skipped']}, failed {results['failed']}" + + return overall_success, summary_message, results + + except Exception as e: + return False, f"Error syncing contract content: {str(e)}", {} + + def sync_user_content(self, user_id: str, db: Session) -> Tuple[bool, str, Dict]: + """ + Sync analytics data for all content owned by a user + + Args: + user_id: ID of the user + db: Database session + + Returns: + Tuple of (success, message, results_summary) + """ + try: + # Get all active content mappings for the user + content_mappings = db.query(ContractContentMapping).filter( + ContractContentMapping.user_id == user_id, + ContractContentMapping.is_active == True + ).all() + + if not content_mappings: + return True, "No content linked for this user", {} + + results = { + 'total': len(content_mappings), + 'successful': 0, + 'failed': 0, + 'skipped': 0, + 'errors': [] + } + + for mapping in content_mappings: + success, message = self.sync_content_data(mapping.id, db) + + if success: + if "up to date" in message: + results['skipped'] += 1 + else: + results['successful'] += 1 + else: + results['failed'] += 1 + results['errors'].append({ + 'content_id': mapping.content_id, + 'platform': mapping.platform, + 'error': message + }) + + overall_success = results['failed'] == 0 + summary_message = f"Synced {results['successful']} items, skipped {results['skipped']}, failed {results['failed']}" + + return overall_success, summary_message, results + + except Exception as e: + return False, f"Error syncing user content: {str(e)}", {} + + def get_content_analytics(self, content_mapping_id: str, db: Session, + date_range: Optional[Tuple[datetime, datetime]] = None) -> Optional[List[Dict]]: + """ + Get analytics data for specific content + + Args: + content_mapping_id: ID of the content mapping + db: Database session + date_range: Optional tuple of (start_date, end_date) + + Returns: + List of analytics data or None if not found + """ + try: + query = db.query(ContentAnalytics).filter( + ContentAnalytics.contract_content_id == content_mapping_id + ) + + if date_range: + start_date, end_date = date_range + query = query.filter( + and_( + ContentAnalytics.metrics_collected_at >= start_date, + ContentAnalytics.metrics_collected_at <= end_date + ) + ) + + analytics = query.order_by(ContentAnalytics.metrics_collected_at.desc()).all() + + result = [] + for record in analytics: + result.append({ + 'id': record.id, + 'impressions': record.impressions, + 'reach': record.reach, + 'likes': record.likes, + 'comments': record.comments, + 'shares': record.shares, + 'saves': record.saves, + 'clicks': record.clicks, + 'engagement_rate': float(record.engagement_rate) if record.engagement_rate else 0.0, + 'demographics': record.demographics, + 'content_published_at': record.content_published_at.isoformat() if record.content_published_at else None, + 'metrics_collected_at': record.metrics_collected_at.isoformat(), + 'created_at': record.created_at.isoformat() + }) + + return result + + except Exception as e: + print(f"Error getting content analytics: {e}") + return None + + def _is_recently_synced(self, content_mapping: ContractContentMapping, db: Session, + hours_threshold: int = 1) -> bool: + """Check if content was recently synced""" + try: + threshold_time = datetime.utcnow() - timedelta(hours=hours_threshold) + + recent_analytics = db.query(ContentAnalytics).filter( + ContentAnalytics.contract_content_id == content_mapping.id, + ContentAnalytics.metrics_collected_at >= threshold_time + ).first() + + return recent_analytics is not None + + except Exception: + return False + + def _check_rate_limit(self, platform: str, user_id: str) -> bool: + """Check if API rate limit allows for another request""" + try: + current_time = datetime.utcnow() + user_key = f"{platform}:{user_id}" + + if user_key not in self.usage_tracker: + self.usage_tracker[user_key] = { + 'hourly': {'count': 0, 'reset_time': current_time + timedelta(hours=1)}, + 'daily': {'count': 0, 'reset_time': current_time + timedelta(days=1)} + } + + user_usage = self.usage_tracker[user_key] + + # Reset counters if time has passed + if current_time >= user_usage['hourly']['reset_time']: + user_usage['hourly'] = {'count': 0, 'reset_time': current_time + timedelta(hours=1)} + + if current_time >= user_usage['daily']['reset_time']: + user_usage['daily'] = {'count': 0, 'reset_time': current_time + timedelta(days=1)} + + # Check limits + platform_limits = self.rate_limits.get(platform, {'requests_per_hour': 100, 'requests_per_day': 1000}) + + if user_usage['hourly']['count'] >= platform_limits['requests_per_hour']: + return False + + if user_usage['daily']['count'] >= platform_limits['requests_per_day']: + return False + + return True + + except Exception as e: + print(f"Error checking rate limit: {e}") + return True # Allow request if rate limit check fails + + def _update_usage_tracker(self, platform: str, user_id: str): + """Update API usage tracker""" + try: + user_key = f"{platform}:{user_id}" + + if user_key in self.usage_tracker: + self.usage_tracker[user_key]['hourly']['count'] += 1 + self.usage_tracker[user_key]['daily']['count'] += 1 + + except Exception as e: + print(f"Error updating usage tracker: {e}") + + def _store_content_analytics(self, content_mapping: ContractContentMapping, + normalized_metrics: NormalizedMetrics, db: Session) -> bool: + """Store normalized metrics in the database""" + try: + # Create new analytics record + analytics = ContentAnalytics( + contract_content_id=content_mapping.id, + impressions=normalized_metrics.metrics.get('impressions', 0), + reach=normalized_metrics.metrics.get('reach', 0), + likes=normalized_metrics.metrics.get('likes', 0), + comments=normalized_metrics.metrics.get('comments', 0), + shares=normalized_metrics.metrics.get('shares', 0), + saves=normalized_metrics.metrics.get('saves', 0), + clicks=normalized_metrics.metrics.get('clicks', 0), + engagement_rate=normalized_metrics.metrics.get('engagement_rate', 0.0), + demographics=normalized_metrics.demographics, + metrics_collected_at=normalized_metrics.collected_at + ) + + db.add(analytics) + db.commit() + + return True + + except Exception as e: + db.rollback() + print(f"Error storing content analytics: {e}") + return False + + def validate_platform_credentials(self, platform: str, user_id: str, db: Session) -> Tuple[bool, str]: + """Validate that user has valid credentials for the platform""" + try: + user_token = db.query(UserSocialToken).filter( + UserSocialToken.user_id == user_id, + UserSocialToken.platform == platform, + UserSocialToken.is_active == True + ).first() + + if not user_token: + return False, f"No {platform} account connected" + + # Check if token is expired (for platforms that have expiration) + if platform == 'youtube' and user_token.token_expires_at: + if user_token.token_expires_at <= datetime.utcnow(): + # Try to refresh token + success = oauth_service.refresh_youtube_token(user_token, db) + if not success: + return False, f"{platform} token expired and refresh failed" + + # Test the token with a simple API call + collector = DataCollectorFactory.get_collector(platform) + + if platform == 'instagram': + # Test Instagram token + test_url = "https://graph.instagram.com/me" + import requests + response = requests.get(test_url, params={'access_token': user_token.access_token}) + if response.status_code != 200: + return False, f"{platform} token is invalid" + + elif platform == 'youtube': + # Test YouTube token + test_url = "https://www.googleapis.com/youtube/v3/channels" + import requests + response = requests.get(test_url, params={ + 'part': 'snippet', + 'mine': 'true', + 'access_token': user_token.access_token + }) + if response.status_code != 200: + return False, f"{platform} token is invalid" + + return True, f"{platform} credentials are valid" + + except Exception as e: + return False, f"Error validating {platform} credentials: {str(e)}" + + +# Global instance +data_ingestion_service = DataIngestionService() \ No newline at end of file diff --git a/Backend/app/services/db_service.py b/Backend/app/services/db_service.py index ccb4199..6f178ee 100644 --- a/Backend/app/services/db_service.py +++ b/Backend/app/services/db_service.py @@ -7,6 +7,8 @@ load_dotenv() url: str = os.getenv("SUPABASE_URL") key: str = os.getenv("SUPABASE_KEY") +if not url or not key: + raise ValueError("SUPABASE_URL and SUPABASE_KEY must be set in environment variables") supabase: Client = create_client(url, key) diff --git a/Backend/app/services/pricing_service.py b/Backend/app/services/pricing_service.py new file mode 100644 index 0000000..daad6e7 --- /dev/null +++ b/Backend/app/services/pricing_service.py @@ -0,0 +1,570 @@ +import json +import math +from typing import List, Dict, Optional, Tuple +from datetime import datetime, timedelta +from supabase import create_client, Client +import os +from dotenv import load_dotenv + +load_dotenv() + +class PricingService: + def __init__(self): + supabase_url = os.getenv("SUPABASE_URL") + supabase_key = os.getenv("SUPABASE_KEY") + + if not supabase_url or not supabase_key: + raise ValueError("SUPABASE_URL and SUPABASE_KEY must be set") + + self.supabase: Client = create_client(supabase_url, supabase_key) + + def find_similar_contracts( + self, + creator_followers: int, + creator_engagement_rate: float, + content_type: str, + campaign_type: str, + platform: str, + duration_weeks: int, + exclusivity_level: str = "none", + limit: int = 10 + ) -> List[Dict]: + """ + Find similar contracts based on creator metrics and campaign parameters + """ + try: + # Build similarity query - less restrictive to get more matches + query = self.supabase.table("contracts").select( + "*, users!creator_id(username, email), users!brand_id(username, email)" + ).not_.is_("total_budget", "null") + + # Filter by content_type for better matching + if content_type: + # Handle new content types by extracting the platform + platform = content_type.split('_')[0] if '_' in content_type else content_type + query = query.ilike("content_type", f"%{platform}%") + + # Don't filter by platform or campaign_type initially to get more matches + + response = query.execute() + contracts = response.data + + print(f"Found {len(contracts)} contracts in database") + print(f"Query filters: content_type={content_type}, platform={platform}") + + if not contracts: + print("No contracts found with current filters") + return [] + + # Calculate similarity scores + scored_contracts = [] + for contract in contracts: + score = self._calculate_similarity_score( + contract, + creator_followers, + creator_engagement_rate, + content_type, + campaign_type, + platform, + duration_weeks, + exclusivity_level + ) + + print(f"Contract {contract.get('id', 'unknown')}: score={score:.3f}, followers={contract.get('creator_followers')}, engagement={contract.get('creator_engagement_rate')}") + + if score > 0.05: # Very low minimum similarity threshold for testing + scored_contracts.append({ + **contract, + "similarity_score": score + }) + + # Sort by similarity score and return top matches + scored_contracts.sort(key=lambda x: x["similarity_score"], reverse=True) + return scored_contracts[:limit] + + except Exception as e: + print(f"Error finding similar contracts: {e}") + return [] + + def _calculate_similarity_score( + self, + contract: Dict, + target_followers: int, + target_engagement: float, + target_content_type: str, + target_campaign_type: str, + target_platform: str, + target_duration: int, + target_exclusivity: str + ) -> float: + """ + Calculate similarity score between target contract and historical contract + """ + score = 0.0 + weights = { + "follower_range": 0.25, + "engagement_rate": 0.20, + "content_type": 0.15, + "platform": 0.15, + "campaign_type": 0.10, + "duration": 0.10, + "exclusivity": 0.05 + } + + # 1. Follower range similarity (logarithmic scale) + contract_followers = contract.get("creator_followers", 0) + if contract_followers > 0 and target_followers > 0: + follower_diff = abs(math.log10(contract_followers) - math.log10(target_followers)) + follower_score = max(0, 1 - (follower_diff / 3)) # More lenient normalization + score += follower_score * weights["follower_range"] + + # 2. Engagement rate similarity + contract_engagement = contract.get("creator_engagement_rate", 0) + if contract_engagement > 0 and target_engagement > 0: + engagement_diff = abs(contract_engagement - target_engagement) + engagement_score = max(0, 1 - (engagement_diff / 10)) # 10% difference threshold + score += engagement_score * weights["engagement_rate"] + + # 3. Content type exact match + if contract.get("content_type") == target_content_type: + score += weights["content_type"] + + # 4. Platform exact match + if contract.get("platform") == target_platform: + score += weights["platform"] + + # 5. Campaign type exact match + if contract.get("campaign_type") == target_campaign_type: + score += weights["campaign_type"] + + # 6. Duration similarity + contract_duration = contract.get("duration_weeks", 0) + if contract_duration > 0 and target_duration > 0: + duration_diff = abs(contract_duration - target_duration) + duration_score = max(0, 1 - (duration_diff / 4)) # 4 weeks difference threshold + score += duration_score * weights["duration"] + + # 7. Exclusivity level match + if contract.get("exclusivity_level") == target_exclusivity: + score += weights["exclusivity"] + + return min(score, 1.0) # Cap at 1.0 + + def generate_price_recommendation( + self, + similar_contracts: List[Dict], + creator_followers: int, + creator_engagement_rate: float, + content_type: str, + campaign_type: str, + platform: str, + duration_weeks: int, + exclusivity_level: str = "none" + ) -> Dict: + """ + Generate price recommendation with fallback handling + """ + # Check if we have enough similar contracts for reliable pricing + has_sufficient_data = len(similar_contracts) >= 3 + + if not has_sufficient_data: + # Use fallback pricing with market-based calculations + base_price = self._calculate_fallback_price( + creator_followers, creator_engagement_rate, content_type, + campaign_type, platform, duration_weeks, exclusivity_level + ) + + return { + "recommended_price": base_price, + "confidence_score": 0.3, # Low confidence for fallback + "reasoning": f"Limited similar contracts found ({len(similar_contracts)} contracts). Using market-based pricing with industry averages. Consider this as a starting point and adjust based on your specific requirements.", + "similar_contracts_used": similar_contracts, + "market_factors": { + "fallback_used": True, + "similar_contracts_count": len(similar_contracts), + "reason": "Insufficient similar contracts for AI-powered pricing" + }, + "is_fallback": True + } + """ + Generate price recommendation based on similar contracts + """ + if not similar_contracts: + return { + "recommended_price": 0, + "confidence_score": 0, + "reasoning": "No similar contracts found", + "similar_contracts_used": [], + "market_factors": {} + } + + # Calculate weighted average price + total_weight = 0 + weighted_price_sum = 0 + used_contracts = [] + + for contract in similar_contracts: + weight = contract["similarity_score"] + price = contract.get("total_budget", 0) + + if price > 0: + weighted_price_sum += price * weight + total_weight += weight + used_contracts.append({ + "contract_id": contract["id"], + "price": price, + "similarity_score": weight, + "creator_followers": contract.get("creator_followers"), + "engagement_rate": contract.get("creator_engagement_rate") + }) + + if total_weight == 0: + return { + "recommended_price": 0, + "confidence_score": 0, + "reasoning": "No valid pricing data in similar contracts", + "similar_contracts_used": [], + "market_factors": {} + } + + base_price = weighted_price_sum / total_weight + + # Apply market adjustments + adjusted_price = self._apply_market_adjustments( + base_price, + creator_followers, + creator_engagement_rate, + content_type, + platform, + duration_weeks, + exclusivity_level + ) + + # Calculate confidence score + confidence_score = self._calculate_confidence_score(similar_contracts, used_contracts) + + # Generate reasoning + reasoning = self._generate_reasoning(used_contracts, adjusted_price, base_price) + + return { + "recommended_price": round(adjusted_price, 2), + "confidence_score": round(confidence_score, 3), + "reasoning": reasoning, + "similar_contracts_used": used_contracts, + "market_factors": { + "base_price": round(base_price, 2), + "adjustment_factor": round(adjusted_price / base_price, 3) if base_price > 0 else 1.0, + "follower_multiplier": self._get_follower_multiplier(creator_followers), + "engagement_multiplier": self._get_engagement_multiplier(creator_engagement_rate), + "content_type_multiplier": self._get_content_type_multiplier(content_type), + "platform_multiplier": self._get_platform_multiplier(platform), + "duration_multiplier": self._get_duration_multiplier(duration_weeks), + "exclusivity_multiplier": self._get_exclusivity_multiplier(exclusivity_level) + } + } + + def _apply_market_adjustments( + self, + base_price: float, + followers: int, + engagement_rate: float, + content_type: str, + platform: str, + duration_weeks: int, + exclusivity_level: str + ) -> float: + """ + Apply market-based adjustments to the base price + """ + adjusted_price = base_price + + # Follower-based adjustment + follower_multiplier = self._get_follower_multiplier(followers) + adjusted_price *= follower_multiplier + + # Engagement-based adjustment + engagement_multiplier = self._get_engagement_multiplier(engagement_rate) + adjusted_price *= engagement_multiplier + + # Content type adjustment + content_multiplier = self._get_content_type_multiplier(content_type) + adjusted_price *= content_multiplier + + # Platform adjustment + platform_multiplier = self._get_platform_multiplier(platform) + adjusted_price *= platform_multiplier + + # Duration adjustment + duration_multiplier = self._get_duration_multiplier(duration_weeks) + adjusted_price *= duration_multiplier + + # Exclusivity adjustment + exclusivity_multiplier = self._get_exclusivity_multiplier(exclusivity_level) + adjusted_price *= exclusivity_multiplier + + return adjusted_price + + def _get_follower_multiplier(self, followers: int) -> float: + """Calculate price multiplier based on follower count""" + if followers < 1000: + return 0.5 + elif followers < 5000: + return 0.8 + elif followers < 10000: + return 1.0 + elif followers < 50000: + return 1.2 + elif followers < 100000: + return 1.5 + elif followers < 500000: + return 2.0 + else: + return 3.0 + + def _get_engagement_multiplier(self, engagement_rate: float) -> float: + """Calculate price multiplier based on engagement rate""" + if engagement_rate < 1.0: + return 0.7 + elif engagement_rate < 2.0: + return 0.9 + elif engagement_rate < 3.0: + return 1.0 + elif engagement_rate < 5.0: + return 1.2 + elif engagement_rate < 8.0: + return 1.5 + else: + return 2.0 + + def _get_content_type_multiplier(self, content_type: str) -> float: + """Calculate price multiplier based on content type""" + multipliers = { + # YouTube content types + "youtube_shorts": 0.8, + "youtube_video": 1.5, + "youtube_live": 1.3, + # Instagram content types + "instagram_post": 1.0, + "instagram_reel": 1.2, + "instagram_story": 0.8, + "instagram_live": 1.3, + # TikTok content types + "tiktok_video": 1.1, + "tiktok_live": 1.3, + # Facebook content types + "facebook_post": 0.9, + "facebook_live": 1.3, + # Twitter content types + "twitter_post": 0.8, + "twitter_space": 1.2, + # LinkedIn content types + "linkedin_post": 1.1, + "linkedin_article": 1.4, + # Other content types + "blog_post": 1.2, + "podcast": 1.5, + "newsletter": 1.0, + # Legacy support + "video": 1.5, + "live": 1.3, + "story": 0.8, + "post": 1.0, + "review": 1.2, + "tutorial": 1.4 + } + return multipliers.get(content_type.lower(), 1.0) + + def _get_platform_multiplier(self, platform: str) -> float: + """Calculate price multiplier based on platform""" + multipliers = { + "youtube": 1.3, + "instagram": 1.0, + "tiktok": 0.9, + "twitter": 0.8, + "facebook": 0.7, + "linkedin": 1.1 + } + return multipliers.get(platform.lower(), 1.0) + + def _get_duration_multiplier(self, duration_weeks: int) -> float: + """Calculate price multiplier based on campaign duration""" + if duration_weeks <= 1: + return 0.8 + elif duration_weeks <= 2: + return 0.9 + elif duration_weeks <= 4: + return 1.0 + elif duration_weeks <= 8: + return 1.1 + else: + return 1.2 + + def _get_exclusivity_multiplier(self, exclusivity_level: str) -> float: + """Calculate price multiplier based on exclusivity level""" + multipliers = { + "none": 1.0, + "platform": 1.2, + "category": 1.5, + "full": 2.0 + } + return multipliers.get(exclusivity_level.lower(), 1.0) + + def _calculate_confidence_score(self, similar_contracts: List[Dict], used_contracts: List[Dict]) -> float: + """Calculate confidence score based on data quality and quantity""" + if not used_contracts: + return 0.0 + + # Base confidence on number of similar contracts + num_contracts = len(used_contracts) + base_confidence = min(num_contracts / 5, 1.0) # Max confidence at 5+ contracts + + # Adjust based on similarity scores + avg_similarity = sum(c["similarity_score"] for c in used_contracts) / len(used_contracts) + + # Adjust based on price consistency + prices = [c["price"] for c in used_contracts] + if len(prices) > 1: + price_variance = (max(prices) - min(prices)) / max(prices) + consistency_factor = max(0, 1 - price_variance) + else: + consistency_factor = 0.5 + + # Calculate final confidence + confidence = (base_confidence * 0.4 + avg_similarity * 0.4 + consistency_factor * 0.2) + return min(confidence, 1.0) + + def _generate_reasoning(self, used_contracts: List[Dict], final_price: float, base_price: float) -> str: + """Generate human-readable reasoning for the price recommendation""" + if not used_contracts: + return "No similar contracts found for comparison." + + num_contracts = len(used_contracts) + avg_similarity = sum(c["similarity_score"] for c in used_contracts) / num_contracts + + reasoning = f"Based on {num_contracts} similar contracts with {avg_similarity:.1%} average similarity:" + + # Add price range info + prices = [c["price"] for c in used_contracts] + price_range = f"${min(prices):,.0f} - ${max(prices):,.0f}" + reasoning += f"\n• Price range from similar contracts: {price_range}" + + # Add adjustment explanation + if abs(final_price - base_price) > 0.01: + adjustment = "increased" if final_price > base_price else "decreased" + reasoning += f"\n• Price {adjustment} by {abs(final_price - base_price):.1%} based on market factors" + + # Add top similar contract details + top_contract = max(used_contracts, key=lambda x: x["similarity_score"]) + reasoning += f"\n• Most similar contract: ${top_contract['price']:,.0f} ({(top_contract['similarity_score']*100):.0f}% match)" + + return reasoning + + def learn_from_outcome( + self, + contract_id: str, + recommended_price: float, + actual_price: float, + satisfaction_score: int, + roi_achieved: float, + repeat_business: bool + ) -> bool: + """ + Learn from contract outcomes to improve future recommendations + """ + try: + # Store pricing feedback + feedback_data = { + "contract_id": contract_id, + "recommended_price": recommended_price, + "actual_price": actual_price, + "price_accuracy_score": self._calculate_accuracy_score(recommended_price, actual_price), + "market_conditions": "normal", # Could be enhanced with market data + "feedback_notes": f"Satisfaction: {satisfaction_score}/10, ROI: {roi_achieved}%, Repeat: {repeat_business}" + } + + self.supabase.table("pricing_feedback").insert(feedback_data).execute() + + # Update contract with outcome data + outcome_data = { + "brand_satisfaction_score": satisfaction_score, + "roi_achieved": roi_achieved, + "repeat_business": repeat_business, + "updated_at": datetime.now().isoformat() + } + + self.supabase.table("contracts").update(outcome_data).eq("id", contract_id).execute() + + return True + + except Exception as e: + print(f"Error learning from outcome: {e}") + return False + + def _calculate_accuracy_score(self, recommended: float, actual: float) -> int: + """Calculate accuracy score (1-10) for price recommendation""" + if actual == 0: + return 5 # Neutral if no actual price + + percentage_diff = abs(recommended - actual) / actual + + if percentage_diff <= 0.05: # Within 5% + return 10 + elif percentage_diff <= 0.10: # Within 10% + return 8 + elif percentage_diff <= 0.15: # Within 15% + return 6 + elif percentage_diff <= 0.25: # Within 25% + return 4 + elif percentage_diff <= 0.50: # Within 50% + return 2 + else: + return 1 + + def _calculate_fallback_price( + self, + creator_followers: int, + creator_engagement_rate: float, + content_type: str, + campaign_type: str, + platform: str, + duration_weeks: int, + exclusivity_level: str + ) -> float: + """ + Calculate fallback price using market-based pricing when insufficient similar contracts are found + """ + # Base price per follower (industry average) + base_price_per_follower = 0.01 # $0.01 per follower + + # Calculate base price + base_price = creator_followers * base_price_per_follower + + # Apply engagement rate multiplier + engagement_multiplier = self._get_engagement_multiplier(creator_engagement_rate) + base_price *= engagement_multiplier + + # Apply content type multiplier + content_multiplier = self._get_content_type_multiplier(content_type) + base_price *= content_multiplier + + # Apply platform multiplier + platform_multiplier = self._get_platform_multiplier(platform) + base_price *= platform_multiplier + + # Apply duration multiplier + duration_multiplier = self._get_duration_multiplier(duration_weeks) + base_price *= duration_multiplier + + # Apply exclusivity multiplier + exclusivity_multiplier = self._get_exclusivity_multiplier(exclusivity_level) + base_price *= exclusivity_multiplier + + # Apply campaign type multiplier + campaign_multiplier = 1.2 if campaign_type == "product_launch" else 1.0 + base_price *= campaign_multiplier + + # Ensure minimum price + min_price = 500 + base_price = max(base_price, min_price) + + return round(base_price, 2) \ No newline at end of file diff --git a/Backend/app/services/redis_client.py b/Backend/app/services/redis_client.py index d2fb922..8bd3541 100644 --- a/Backend/app/services/redis_client.py +++ b/Backend/app/services/redis_client.py @@ -1,6 +1,27 @@ import redis.asyncio as redis +import os +import json -redis_client = redis.Redis(host="localhost", port=6379, decode_responses=True) +REDIS_HOST = os.getenv("REDIS_HOST", "your-redis-cloud-host") +REDIS_PORT = int(os.getenv("REDIS_PORT", 12345)) # replace with your port +REDIS_PASSWORD = os.getenv("REDIS_PASSWORD", "your-redis-cloud-password") + +redis_client = redis.Redis( + host=REDIS_HOST, + port=REDIS_PORT, + password=REDIS_PASSWORD, + decode_responses=True, + ssl=False # Redis Cloud connection works without SSL +) + +SESSION_TTL = 1800 # 30 minutes + +async def get_session_state(session_id: str): + state = await redis_client.get(f"session:{session_id}") + return json.loads(state) if state else {} + +async def save_session_state(session_id: str, state: dict): + await redis_client.set(f"session:{session_id}", json.dumps(state), ex=SESSION_TTL) async def get_redis(): diff --git a/Backend/app/services/roi_service.py b/Backend/app/services/roi_service.py new file mode 100644 index 0000000..fda10a5 --- /dev/null +++ b/Backend/app/services/roi_service.py @@ -0,0 +1,534 @@ +""" +ROI Calculation Service + +This service handles all ROI (Return on Investment) calculations for sponsorship campaigns, +including cost per acquisition, revenue tracking, trend analysis, and goal tracking. +Enhanced with Redis caching for improved performance. +""" + +from typing import Dict, List, Optional, Tuple, Any, Iterator +from datetime import datetime, timedelta, timezone +from decimal import Decimal, ROUND_HALF_UP +from sqlalchemy.orm import Session +from sqlalchemy import and_, func, desc +from dataclasses import dataclass +import asyncio + +from app.models.models import ( + CampaignMetrics, + Sponsorship, + ContractContentMapping, + ContentAnalytics, + SponsorshipPayment +) +from app.services.redis_client import analytics_cache +from app.services.database_optimization_service import db_optimization_service + + +@dataclass +class ROIMetrics: + """Data class for ROI calculation results""" + campaign_id: str + total_spend: Decimal + total_revenue: Decimal + roi_percentage: Decimal + cost_per_acquisition: Decimal + conversions: int + impressions: int + reach: int + engagement_rate: Decimal + click_through_rate: Decimal + period_start: datetime + period_end: datetime + + +@dataclass +class ROITrend: + """Data class for ROI trend analysis""" + period: str + roi_percentage: Decimal + spend: Decimal + revenue: Decimal + conversions: int + date: datetime + + +@dataclass +class ROITarget: + """Data class for ROI target tracking""" + target_roi: Decimal + actual_roi: Decimal + target_cpa: Decimal + actual_cpa: Decimal + target_met: bool + variance_percentage: Decimal + + +class ROIService: + """Service for calculating ROI metrics and trends""" + + def __init__(self, db: Session): + self.db = db + + def calculate_campaign_roi( + self, + campaign_id: str, + start_date: Optional[datetime] = None, + end_date: Optional[datetime] = None, + use_cache: bool = True + ) -> Optional[ROIMetrics]: + """ + Calculate ROI metrics for a specific campaign with caching + + Args: + campaign_id: The campaign to calculate ROI for + start_date: Start date for the calculation period + end_date: End date for the calculation period + use_cache: Whether to use Redis cache + + Returns: + ROIMetrics object with calculated values or None if insufficient data + """ + # Set default date range if not provided + if not end_date: + end_date = datetime.now(timezone.utc) + if not start_date: + start_date = end_date - timedelta(days=30) + + # Synchronous version intentionally does not use Redis cache + + # Get campaign spend from sponsorship budget and payments + campaign = self.db.query(Sponsorship).filter(Sponsorship.id == campaign_id).first() + if not campaign: + return None + + total_spend = self._calculate_campaign_spend(campaign_id, start_date, end_date) + if total_spend <= 0: + return None + + # Aggregate directly from CampaignMetrics for deterministic behavior in tests + metrics = self.db.query(CampaignMetrics).filter( + and_( + CampaignMetrics.campaign_id == campaign_id, + CampaignMetrics.recorded_at >= start_date, + CampaignMetrics.recorded_at <= end_date, + ) + ).all() + + if not metrics: + return None + + total_revenue = Decimal(str(sum((m.revenue or 0) for m in metrics))) + total_conversions = sum(m.conversions or 0 for m in metrics) + total_impressions = sum(m.impressions or 0 for m in metrics) + total_reach = sum(m.reach or 0 for m in metrics) + total_clicks = sum(m.clicks or 0 for m in metrics) + avg_engagement_rate = self._calculate_average_engagement_rate(metrics) + + roi_percentage = self._calculate_roi_percentage(total_revenue, total_spend) + cost_per_acquisition = self._calculate_cpa(total_spend, total_conversions) + click_through_rate = self._calculate_ctr(total_clicks, total_impressions) + + roi_metrics = ROIMetrics( + campaign_id=campaign_id, + total_spend=total_spend, + total_revenue=total_revenue, + roi_percentage=roi_percentage, + cost_per_acquisition=cost_per_acquisition, + conversions=total_conversions, + impressions=total_impressions, + reach=total_reach, + engagement_rate=avg_engagement_rate, + click_through_rate=click_through_rate, + period_start=start_date, + period_end=end_date + ) + + return roi_metrics + + async def calculate_campaign_roi_async( + self, + campaign_id: str, + start_date: Optional[datetime] = None, + end_date: Optional[datetime] = None, + use_cache: bool = True + ) -> Optional[ROIMetrics]: + """Async wrapper for ROI calculation with caching.""" + if use_cache: + try: + # Try to get from cache first + cached_result = await self.cache_service.get_roi_metrics(campaign_id, start_date, end_date) + if cached_result: + return ROIMetrics(**cached_result) + except Exception: + pass + + # Calculate ROI synchronously + result = self.calculate_campaign_roi(campaign_id, start_date, end_date, use_cache=False) + + # Cache the result if we have one + if result and use_cache: + try: + await self.cache_service.set_roi_metrics(campaign_id, start_date, end_date, result.dict()) + except Exception: + pass + + return result + + # Make the sync method awaitable for backward compatibility in tests + def calculate_campaign_roi_awaitable( + self, + campaign_id: str, + start_date: Optional[datetime] = None, + end_date: Optional[datetime] = None, + use_cache: bool = True + ): + """Awaitable wrapper for backward compatibility with tests.""" + return self.calculate_campaign_roi_async(campaign_id, start_date, end_date, use_cache) + + def calculate_roi_trends( + self, + campaign_id: str, + period_type: str = 'daily', + num_periods: int = 30 + ) -> List[ROITrend]: + """ + Calculate ROI trends over time periods + + Args: + campaign_id: The campaign to analyze + period_type: 'daily', 'weekly', or 'monthly' + num_periods: Number of periods to analyze + + Returns: + List of ROITrend objects ordered by date + """ + end_date = datetime.now(timezone.utc) + + # Calculate period duration + if period_type == 'daily': + period_delta = timedelta(days=1) + start_date = end_date - timedelta(days=num_periods) + elif period_type == 'weekly': + period_delta = timedelta(weeks=1) + start_date = end_date - timedelta(weeks=num_periods) + elif period_type == 'monthly': + period_delta = timedelta(days=30) + start_date = end_date - timedelta(days=num_periods * 30) + else: + raise ValueError("period_type must be 'daily', 'weekly', or 'monthly'") + + trends = [] + current_date = start_date + + while current_date < end_date: + period_end = min(current_date + period_delta, end_date) + + # Get metrics for this period + period_metrics = self.db.query(CampaignMetrics).filter( + and_( + CampaignMetrics.campaign_id == campaign_id, + CampaignMetrics.recorded_at >= current_date, + CampaignMetrics.recorded_at < period_end + ) + ).all() + + if period_metrics: + period_spend = self._calculate_campaign_spend(campaign_id, current_date, period_end) + period_revenue = sum(m.revenue or Decimal('0') for m in period_metrics) + period_conversions = sum(m.conversions or 0 for m in period_metrics) + period_roi = self._calculate_roi_percentage(period_revenue, period_spend) + + trends.append(ROITrend( + period=f"{current_date.strftime('%Y-%m-%d')} to {period_end.strftime('%Y-%m-%d')}", + roi_percentage=period_roi, + spend=period_spend, + revenue=period_revenue, + conversions=period_conversions, + date=current_date + )) + + current_date = period_end + + return sorted(trends, key=lambda x: x.date) + + def compare_roi_to_targets( + self, + campaign_id: str, + target_roi: Decimal, + target_cpa: Optional[Decimal] = None, + start_date: Optional[datetime] = None, + end_date: Optional[datetime] = None + ) -> Optional[ROITarget]: + """ + Compare actual ROI performance to targets + + Args: + campaign_id: The campaign to analyze + target_roi: Target ROI percentage + target_cpa: Target cost per acquisition (optional) + start_date: Start date for comparison period + end_date: End date for comparison period + + Returns: + ROITarget object with comparison results + """ + roi_metrics = self.calculate_campaign_roi(campaign_id, start_date, end_date) + if not roi_metrics: + return None + + actual_roi = roi_metrics.roi_percentage + actual_cpa = roi_metrics.cost_per_acquisition + + # Calculate variance + roi_variance = self._calculate_percentage_variance(actual_roi, target_roi) + + # Determine if targets are met + roi_target_met = actual_roi >= target_roi + cpa_target_met = True + if target_cpa is not None: + cpa_target_met = actual_cpa <= target_cpa + + target_met = roi_target_met and cpa_target_met + + return ROITarget( + target_roi=target_roi, + actual_roi=actual_roi, + target_cpa=target_cpa or Decimal('0'), + actual_cpa=actual_cpa, + target_met=target_met, + variance_percentage=roi_variance + ) + + def get_campaign_roi_summary( + self, + campaign_ids: List[str], + start_date: Optional[datetime] = None, + end_date: Optional[datetime] = None + ) -> Dict[str, ROIMetrics]: + """ + Get ROI summary for multiple campaigns + + Args: + campaign_ids: List of campaign IDs to analyze + start_date: Start date for analysis + end_date: End date for analysis + + Returns: + Dictionary mapping campaign_id to ROIMetrics + """ + summary = {} + + for campaign_id in campaign_ids: + roi_metrics = self.calculate_campaign_roi(campaign_id, start_date, end_date) + if roi_metrics: + summary[campaign_id] = roi_metrics + + return summary + + def calculate_portfolio_roi( + self, + brand_id: str, + start_date: Optional[datetime] = None, + end_date: Optional[datetime] = None, + use_cache: bool = True + ) -> Optional[ROIMetrics]: + """ + Calculate overall ROI across all campaigns for a brand with caching + + Args: + brand_id: The brand to calculate portfolio ROI for + start_date: Start date for calculation + end_date: End date for calculation + use_cache: Whether to use Redis cache + + Returns: + Aggregated ROIMetrics for all brand campaigns + """ + # Set default date range + if not end_date: + end_date = datetime.now(timezone.utc) + if not start_date: + start_date = end_date - timedelta(days=30) + + # Synchronous version intentionally does not use Redis cache + + # Get all campaigns for the brand + campaigns = self.db.query(Sponsorship).filter(Sponsorship.brand_id == brand_id).all() + campaign_ids = [c.id for c in campaigns] + + if not campaign_ids: + return None + + # Use optimized aggregation query + summary = db_optimization_service.get_aggregated_campaign_summary( + self.db, campaign_ids, start_date, end_date + ) + + if not summary: + return None + + # Aggregate across all campaigns + total_spend = Decimal('0') + total_revenue = Decimal('0') + total_conversions = 0 + total_impressions = 0 + total_reach = 0 + total_clicks = 0 + engagement_rates = [] + + for campaign_id in campaign_ids: + campaign_spend = self._calculate_campaign_spend(campaign_id, start_date, end_date) + total_spend += campaign_spend + + if campaign_id in summary: + campaign_summary = summary[campaign_id] + total_revenue += Decimal(str(campaign_summary['total_revenue'])) + total_conversions += campaign_summary['total_conversions'] + total_impressions += campaign_summary['total_impressions'] + total_reach += campaign_summary['total_reach'] + total_clicks += campaign_summary['total_clicks'] + if campaign_summary['avg_engagement_rate'] > 0: + engagement_rates.append(campaign_summary['avg_engagement_rate']) + + if total_spend <= 0: + return None + + # Calculate portfolio metrics + roi_percentage = self._calculate_roi_percentage(total_revenue, total_spend) + cost_per_acquisition = self._calculate_cpa(total_spend, total_conversions) + avg_engagement_rate = Decimal(str(sum(engagement_rates) / len(engagement_rates))) if engagement_rates else Decimal('0') + click_through_rate = self._calculate_ctr(total_clicks, total_impressions) + + portfolio_metrics = ROIMetrics( + campaign_id=f"portfolio_{brand_id}", + total_spend=total_spend, + total_revenue=total_revenue, + roi_percentage=roi_percentage, + cost_per_acquisition=cost_per_acquisition, + conversions=total_conversions, + impressions=total_impressions, + reach=total_reach, + engagement_rate=avg_engagement_rate, + click_through_rate=click_through_rate, + period_start=start_date, + period_end=end_date + ) + + return portfolio_metrics + + async def calculate_portfolio_roi_async( + self, + brand_id: str, + start_date: Optional[datetime] = None, + end_date: Optional[datetime] = None, + use_cache: bool = True + ) -> Optional[ROIMetrics]: + """Async helper that adds Redis caching around the synchronous calculation.""" + if not end_date: + end_date = datetime.now(timezone.utc) + if not start_date: + start_date = end_date - timedelta(days=30) + + if use_cache: + try: + cached = await analytics_cache.get_portfolio_roi(brand_id, start_date, end_date) + if cached: + return ROIMetrics(**cached) + except Exception: + pass + + result = self.calculate_portfolio_roi(brand_id, start_date, end_date, use_cache=False) + + if result and use_cache: + try: + data = { + 'campaign_id': result.campaign_id, + 'total_spend': float(result.total_spend), + 'total_revenue': float(result.total_revenue), + 'roi_percentage': float(result.roi_percentage), + 'cost_per_acquisition': float(result.cost_per_acquisition), + 'conversions': result.conversions, + 'impressions': result.impressions, + 'reach': result.reach, + 'engagement_rate': float(result.engagement_rate), + 'click_through_rate': float(result.click_through_rate), + 'period_start': result.period_start.isoformat(), + 'period_end': result.period_end.isoformat() + } + await analytics_cache.set_portfolio_roi(brand_id, start_date, end_date, data) + except Exception: + pass + return result + + # Private helper methods + + def _calculate_campaign_spend( + self, + campaign_id: str, + start_date: datetime, + end_date: datetime + ) -> Decimal: + """Calculate total spend for a campaign in the given period""" + # Get campaign budget + campaign = self.db.query(Sponsorship).filter(Sponsorship.id == campaign_id).first() + if not campaign or not campaign.budget: + return Decimal('0') + + # For now, use the campaign budget as the spend + # In a more complex system, you might track actual payments over time + payments = self.db.query(SponsorshipPayment).filter( + and_( + SponsorshipPayment.sponsorship_id == campaign_id, + SponsorshipPayment.transaction_date >= start_date, + SponsorshipPayment.transaction_date <= end_date, + SponsorshipPayment.status == 'completed' + ) + ).all() + + total_payments = sum(p.amount for p in payments) + return Decimal(str(total_payments)) if total_payments else campaign.budget + + def _calculate_roi_percentage(self, revenue: Decimal, spend: Decimal) -> Decimal: + """Calculate ROI percentage: ((Revenue - Spend) / Spend) * 100""" + if spend <= 0: + return Decimal('0') + + roi = ((revenue - spend) / spend) * 100 + return roi.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP) + + def _calculate_cpa(self, spend: Decimal, conversions: int) -> Decimal: + """Calculate cost per acquisition: Spend / Conversions""" + if conversions <= 0: + return spend # If no conversions, CPA equals total spend + + cpa = spend / Decimal(str(conversions)) + return cpa.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP) + + def _calculate_ctr(self, clicks: int, impressions: int) -> Decimal: + """Calculate click-through rate: (Clicks / Impressions) * 100""" + if impressions <= 0: + return Decimal('0') + + ctr = (Decimal(str(clicks)) / Decimal(str(impressions))) * 100 + return ctr.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP) + + def _calculate_average_engagement_rate(self, metrics_list: List[CampaignMetrics]) -> Decimal: + """Calculate average engagement rate from metrics list""" + engagement_rates = [m.engagement_rate for m in metrics_list if m.engagement_rate is not None] + + if not engagement_rates: + return Decimal('0') + + # Convert to Decimal and calculate average + decimal_rates = [Decimal(str(rate)) for rate in engagement_rates] + avg_rate = sum(decimal_rates) / len(decimal_rates) + return avg_rate.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP) + + def _calculate_percentage_variance(self, actual: Decimal, target: Decimal) -> Decimal: + """Calculate percentage variance: ((Actual - Target) / Target) * 100""" + if target <= 0: + return Decimal('0') + + variance = ((actual - target) / target) * 100 + return variance.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP) \ No newline at end of file diff --git a/Backend/exports/Updated_Test_Contrayuyuy-2025-08-07.txt b/Backend/exports/Updated_Test_Contrayuyuy-2025-08-07.txt new file mode 100644 index 0000000..d43944d --- /dev/null +++ b/Backend/exports/Updated_Test_Contrayuyuy-2025-08-07.txt @@ -0,0 +1,101 @@ +================================================================================ + CONTRACT DOCUMENT +================================================================================ + +📋 CONTRACT OVERVIEW +---------------------------------------- +Contract Title: Updated Test Contrayuyuy +Contract Type: one-time +Status: Contract status changed to active +Created: 2025-08-02T01:36:43.716801+00:00 +Last Updated: 2025-08-06T00:11:06.910057+00:00 + +👥 PARTIES INVOLVED +---------------------------------------- +Brand ID: u111 +Creator ID: u116 + +📅 TIMELINE +---------------------------------------- +Start Date: 2025-08-06 +End Date: 2025-08-14 + +💰 FINANCIAL DETAILS +---------------------------------------- +Total Budget: $3,500.00 + +Payment Terms: + • Currency: EUR + • Late Fees: Updated late fees + • Final Payment: 60% on completion + • Payment Method: Bank transfer + • Advance Payment: 40% advance + • Payment Schedule: Updated payment schedule + +📦 DELIVERABLES +---------------------------------------- +Format: 1080p HD +Quantity: 5 posts and 2 videos +Timeline: 3 weeks +Content Type: Instagram posts and YouTube videos +Specifications: Detailed specifications for all deliverables +Revision Policy: 2 rounds of revisions included + +📜 TERMS AND CONDITIONS +---------------------------------------- +Exclusivity: Non-exclusive agreement +Jurisdiction: mumbai +Usage Rights: Full usage rights granted. +Additional Terms: Additional terms here +Brand Guidelines: Updated brand guidelines +Content Guidelines: Updated content guidelines +Dispute Resolution: mediation +Disclosure Requirements: Updated FTC compliance + +⚖️ LEGAL COMPLIANCE +---------------------------------------- +Ftc Compliance: True +Disclosure Required: True + +💬 NEGOTIATION HISTORY +---------------------------------------- + +Message 1: +From: test_user +Time: January 01, 2024 at 12:00 AM +Message: Test comment from updated backend +------------------------------ + +Message 2: +From: test_user +Time: January 01, 2024 at 12:00 AM +Message: Another test comment with dedicated columns +------------------------------ + +Message 3: +From: test_user +Time: January 01, 2024 at 12:00 AM +Message: Test comment for frontend visibility +------------------------------ + +Message 4: +From: test_user +Time: August 07, 2025 at 03:50 AM +Message: This is just a comment, should not appear in update history +------------------------------ + +📝 UPDATE HISTORY +---------------------------------------- + +Update 1: +Updated by: test_user +Time: August 07, 2025 at 03:55 AM + • Status Update: Contract status changed to active + • Budget Adjustment: 500.0 +------------------------------ + +================================================================================ + END OF CONTRACT DOCUMENT +================================================================================ +Generated on: August 07, 2025 at 03:49 AM +Document ID: 6f780c78-3ec5-4102-a22b-784174a57f35 diff --git a/Backend/final_contract.txt b/Backend/final_contract.txt new file mode 100644 index 0000000..d43944d --- /dev/null +++ b/Backend/final_contract.txt @@ -0,0 +1,101 @@ +================================================================================ + CONTRACT DOCUMENT +================================================================================ + +📋 CONTRACT OVERVIEW +---------------------------------------- +Contract Title: Updated Test Contrayuyuy +Contract Type: one-time +Status: Contract status changed to active +Created: 2025-08-02T01:36:43.716801+00:00 +Last Updated: 2025-08-06T00:11:06.910057+00:00 + +👥 PARTIES INVOLVED +---------------------------------------- +Brand ID: u111 +Creator ID: u116 + +📅 TIMELINE +---------------------------------------- +Start Date: 2025-08-06 +End Date: 2025-08-14 + +💰 FINANCIAL DETAILS +---------------------------------------- +Total Budget: $3,500.00 + +Payment Terms: + • Currency: EUR + • Late Fees: Updated late fees + • Final Payment: 60% on completion + • Payment Method: Bank transfer + • Advance Payment: 40% advance + • Payment Schedule: Updated payment schedule + +📦 DELIVERABLES +---------------------------------------- +Format: 1080p HD +Quantity: 5 posts and 2 videos +Timeline: 3 weeks +Content Type: Instagram posts and YouTube videos +Specifications: Detailed specifications for all deliverables +Revision Policy: 2 rounds of revisions included + +📜 TERMS AND CONDITIONS +---------------------------------------- +Exclusivity: Non-exclusive agreement +Jurisdiction: mumbai +Usage Rights: Full usage rights granted. +Additional Terms: Additional terms here +Brand Guidelines: Updated brand guidelines +Content Guidelines: Updated content guidelines +Dispute Resolution: mediation +Disclosure Requirements: Updated FTC compliance + +⚖️ LEGAL COMPLIANCE +---------------------------------------- +Ftc Compliance: True +Disclosure Required: True + +💬 NEGOTIATION HISTORY +---------------------------------------- + +Message 1: +From: test_user +Time: January 01, 2024 at 12:00 AM +Message: Test comment from updated backend +------------------------------ + +Message 2: +From: test_user +Time: January 01, 2024 at 12:00 AM +Message: Another test comment with dedicated columns +------------------------------ + +Message 3: +From: test_user +Time: January 01, 2024 at 12:00 AM +Message: Test comment for frontend visibility +------------------------------ + +Message 4: +From: test_user +Time: August 07, 2025 at 03:50 AM +Message: This is just a comment, should not appear in update history +------------------------------ + +📝 UPDATE HISTORY +---------------------------------------- + +Update 1: +Updated by: test_user +Time: August 07, 2025 at 03:55 AM + • Status Update: Contract status changed to active + • Budget Adjustment: 500.0 +------------------------------ + +================================================================================ + END OF CONTRACT DOCUMENT +================================================================================ +Generated on: August 07, 2025 at 03:49 AM +Document ID: 6f780c78-3ec5-4102-a22b-784174a57f35 diff --git a/Backend/migrate_existing_data.py b/Backend/migrate_existing_data.py new file mode 100644 index 0000000..2df34b9 --- /dev/null +++ b/Backend/migrate_existing_data.py @@ -0,0 +1,85 @@ +import os +from dotenv import load_dotenv +from supabase import create_client, Client + +# Load environment variables +load_dotenv() +url: str = os.getenv("SUPABASE_URL") +key: str = os.getenv("SUPABASE_KEY") + +if not url or not key: + raise ValueError("SUPABASE_URL and SUPABASE_KEY must be set in environment variables") + +supabase: Client = create_client(url, key) + +def migrate_existing_data(): + """Migrate existing comments and update history from terms_and_conditions to dedicated columns""" + try: + print("Starting migration of existing data...") + + # Get all contracts + result = supabase.table("contracts").select("*").execute() + contracts = result.data + + print(f"Found {len(contracts)} contracts to process") + + migrated_count = 0 + + for contract in contracts: + contract_id = contract.get("id") + terms_and_conditions = contract.get("terms_and_conditions", {}) + + # Skip if terms_and_conditions is not a dict + if not isinstance(terms_and_conditions, dict): + continue + + update_payload = {} + has_changes = False + + # Migrate comments + if "comments" in terms_and_conditions and terms_and_conditions["comments"]: + comments_data = terms_and_conditions["comments"] + update_payload["comments"] = comments_data + # Remove from terms_and_conditions + del terms_and_conditions["comments"] + has_changes = True + print(f"Migrating {len(comments_data)} comments for contract {contract_id}") + + # Migrate update_history + if "update_history" in terms_and_conditions and terms_and_conditions["update_history"]: + history_data = terms_and_conditions["update_history"] + update_payload["update_history"] = history_data + # Remove from terms_and_conditions + del terms_and_conditions["update_history"] + has_changes = True + print(f"Migrating {len(history_data)} update history entries for contract {contract_id}") + + # Update the contract if there were changes + if has_changes: + update_payload["terms_and_conditions"] = terms_and_conditions + + try: + supabase.table("contracts").update(update_payload).eq("id", contract_id).execute() + migrated_count += 1 + print(f"✅ Successfully migrated contract {contract_id}") + except Exception as e: + print(f"❌ Error migrating contract {contract_id}: {str(e)}") + + print(f"\n🎉 Migration completed! {migrated_count} contracts were updated.") + + # Verify migration + print("\nVerifying migration...") + result = supabase.table("contracts").select("id, comments, update_history").execute() + contracts_after = result.data + + contracts_with_comments = sum(1 for c in contracts_after if c.get("comments")) + contracts_with_history = sum(1 for c in contracts_after if c.get("update_history")) + + print(f"Contracts with comments: {contracts_with_comments}") + print(f"Contracts with update history: {contracts_with_history}") + + except Exception as e: + print(f"❌ Error during migration: {str(e)}") + +if __name__ == "__main__": + migrate_existing_data() \ No newline at end of file diff --git a/Backend/requirements.txt b/Backend/requirements.txt index ea1ab73..8c89382 100644 --- a/Backend/requirements.txt +++ b/Backend/requirements.txt @@ -53,3 +53,5 @@ urllib3==2.3.0 uvicorn==0.34.0 websockets==14.2 yarl==1.18.3 +groq==0.4.2 +openai==1.12.0 diff --git a/Backend/sample_contract.txt b/Backend/sample_contract.txt new file mode 100644 index 0000000..70748ba --- /dev/null +++ b/Backend/sample_contract.txt @@ -0,0 +1,106 @@ +================================================================================ + CONTRACT DOCUMENT +================================================================================ + +📋 CONTRACT OVERVIEW +---------------------------------------- +Contract Title: Updated Test Contrayuyuy +Contract Type: one-time +Status: draft +Created: 2025-08-02T01:36:43.716801+00:00 +Last Updated: 2025-08-06T00:11:06.910057+00:00 + +👥 PARTIES INVOLVED +---------------------------------------- +Brand ID: u111 +Creator ID: u116 + +📅 TIMELINE +---------------------------------------- +Start Date: 2025-08-06 +End Date: 2025-08-14 + +💰 FINANCIAL DETAILS +---------------------------------------- +Total Budget: $3,000.00 + +Payment Terms: + • Currency: EUR + • Late Fees: Updated late fees + • Final Payment: 60% on completion + • Payment Method: Bank transfer + • Advance Payment: 40% advance + • Payment Schedule: Updated payment schedule + +📦 DELIVERABLES +---------------------------------------- +Format: 1080p HD +Quantity: 5 posts and 2 videos +Timeline: 3 weeks +Content Type: Instagram posts and YouTube videos +Specifications: Detailed specifications for all deliverables +Revision Policy: 2 rounds of revisions included + +📜 TERMS AND CONDITIONS +---------------------------------------- +Exclusivity: Non-exclusive agreement +Jurisdiction: mumbai +Usage Rights: Full usage rights granted. +Additional Terms: Additional terms here +Brand Guidelines: Updated brand guidelines +Content Guidelines: Updated content guidelines +Dispute Resolution: mediation +Disclosure Requirements: Updated FTC compliance + +⚖️ LEGAL COMPLIANCE +---------------------------------------- +Ftc Compliance: True +Disclosure Required: True + +💬 NEGOTIATION HISTORY +---------------------------------------- + +Message 1: +From: test_user +Time: January 01, 2024 at 12:00 AM +Message: Test comment from updated backend +------------------------------ + +Message 2: +From: test_user +Time: January 01, 2024 at 12:00 AM +Message: Another test comment with dedicated columns +------------------------------ + +Message 3: +From: test_user +Time: January 01, 2024 at 12:00 AM +Message: Test comment for frontend visibility +------------------------------ + +📝 UPDATE HISTORY +---------------------------------------- + +Update 1: +Updated by: test_user +Time: January 01, 2024 at 12:00 AM + • Comments: Test comment from updated backend +------------------------------ + +Update 2: +Updated by: test_user +Time: January 01, 2024 at 12:00 AM + • Comments: Another test comment with dedicated columns +------------------------------ + +Update 3: +Updated by: test_user +Time: January 01, 2024 at 12:00 AM + • Comments: Test comment for frontend visibility +------------------------------ + +================================================================================ + END OF CONTRACT DOCUMENT +================================================================================ +Generated on: August 07, 2025 at 03:44 AM +Document ID: 6f780c78-3ec5-4102-a22b-784174a57f35 diff --git a/Backend/sql.txt b/Backend/sql.txt index 3ee28b5..bcec363 100644 --- a/Backend/sql.txt +++ b/Backend/sql.txt @@ -39,3 +39,1163 @@ INSERT INTO sponsorship_payments (id, creator_id, brand_id, sponsorship_id, amou (gen_random_uuid(), (SELECT id FROM users WHERE username = 'creator1'), (SELECT id FROM users WHERE username = 'brand1'), (SELECT id FROM sponsorships WHERE title = 'Tech Sponsorship'), 500.00, 'completed', NOW()), (gen_random_uuid(), (SELECT id FROM users WHERE username = 'creator2'), (SELECT id FROM users WHERE username = 'brand1'), (SELECT id FROM sponsorships WHERE title = 'Fashion Sponsorship'), 300.00, 'completed', NOW()), (gen_random_uuid(), (SELECT id FROM users WHERE username = 'creator1'), (SELECT id FROM users WHERE username = 'brand1'), (SELECT id FROM sponsorships WHERE title = 'Gaming Sponsorship'), 400.00, 'pending', NOW()); + +-- ============================================================================ +-- NEW TABLES FOR BRAND DASHBOARD FEATURES +-- ============================================================================ + +-- Create brand_profiles table +CREATE TABLE IF NOT EXISTS brand_profiles ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + user_id VARCHAR REFERENCES users(id) ON DELETE CASCADE, + company_name TEXT, + website TEXT, + industry TEXT, + contact_person TEXT, + contact_email TEXT, + created_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- Create campaign_metrics table +CREATE TABLE IF NOT EXISTS campaign_metrics ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + campaign_id VARCHAR REFERENCES sponsorships(id) ON DELETE CASCADE, + impressions INT, + clicks INT, + conversions INT, + revenue NUMERIC(10,2), + engagement_rate FLOAT, + recorded_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- Create contracts table +CREATE TABLE IF NOT EXISTS contracts ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + sponsorship_id VARCHAR REFERENCES sponsorships(id) ON DELETE CASCADE, + creator_id VARCHAR REFERENCES users(id) ON DELETE CASCADE, + brand_id VARCHAR REFERENCES users(id) ON DELETE CASCADE, + contract_url TEXT, + status TEXT DEFAULT 'draft', -- draft, signed, completed, cancelled + created_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- Create creator_matches table +CREATE TABLE IF NOT EXISTS creator_matches ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + brand_id VARCHAR REFERENCES users(id) ON DELETE CASCADE, + creator_id VARCHAR REFERENCES users(id) ON DELETE CASCADE, + match_score FLOAT, + matched_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- ============================================================================ +-- SAMPLE DATA FOR NEW TABLES +-- ============================================================================ + +-- Insert into brand_profiles table +INSERT INTO brand_profiles (id, user_id, company_name, website, industry, contact_person, contact_email, created_at) VALUES + (gen_random_uuid()::text, (SELECT id FROM users WHERE username = 'brand1'), 'TechCorp Inc.', 'https://techcorp.com', 'Technology', 'John Smith', 'john@techcorp.com', NOW()); + +-- Insert into campaign_metrics table +INSERT INTO campaign_metrics (id, campaign_id, impressions, clicks, conversions, revenue, engagement_rate, recorded_at) VALUES + (gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Tech Sponsorship'), 50000, 2500, 125, 2500.00, 4.5, NOW()), + (gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Fashion Sponsorship'), 30000, 1500, 75, 1500.00, 3.8, NOW()), + (gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Gaming Sponsorship'), 40000, 2000, 100, 2000.00, 4.2, NOW()); + +-- Insert into contracts table +INSERT INTO contracts (id, sponsorship_id, creator_id, brand_id, contract_url, status, created_at) VALUES + (gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Tech Sponsorship'), (SELECT id FROM users WHERE username = 'creator1'), (SELECT id FROM users WHERE username = 'brand1'), 'https://contracts.example.com/tech-contract.pdf', 'signed', NOW()), + (gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Fashion Sponsorship'), (SELECT id FROM users WHERE username = 'creator2'), (SELECT id FROM users WHERE username = 'brand1'), 'https://contracts.example.com/fashion-contract.pdf', 'draft', NOW()); + +-- Insert into creator_matches table +INSERT INTO creator_matches (id, brand_id, creator_id, match_score, matched_at) VALUES + (gen_random_uuid()::text, (SELECT id FROM users WHERE username = 'brand1'), (SELECT id FROM users WHERE username = 'creator1'), 0.95, NOW()), + (gen_random_uuid()::text, (SELECT id FROM users WHERE username = 'brand1'), (SELECT id FROM users WHERE username = 'creator2'), 0.87, NOW()); + + +-- ============================================================================ +-- ENHANCE EXISTING TABLES FOR DASHBOARD FUNCTIONALITY +-- ============================================================================ + +-- Add deadline field to sponsorships table +ALTER TABLE sponsorships ADD COLUMN IF NOT EXISTS deadline TIMESTAMP WITH TIME ZONE; + +-- Add due date to sponsorship_payments table +ALTER TABLE sponsorship_payments ADD COLUMN IF NOT EXISTS due_date TIMESTAMP WITH TIME ZONE; + +-- Add content type to user_posts table +ALTER TABLE user_posts ADD COLUMN IF NOT EXISTS content_type VARCHAR(50) DEFAULT 'post'; + +-- Add top markets to audience_insights table +ALTER TABLE audience_insights ADD COLUMN IF NOT EXISTS top_markets JSONB; + +-- Add engagement tracking to campaign_metrics +ALTER TABLE campaign_metrics ADD COLUMN IF NOT EXISTS total_engagements INTEGER DEFAULT 0; + +-- ============================================================================ +-- UPDATE EXISTING DATA WITH SAMPLE VALUES +-- ============================================================================ + +-- Update sponsorships with sample deadlines +UPDATE sponsorships +SET deadline = created_at + INTERVAL '30 days' +WHERE deadline IS NULL; + +-- Update payments with sample due dates +UPDATE sponsorship_payments +SET due_date = transaction_date + INTERVAL '7 days' +WHERE due_date IS NULL; + +-- Update posts with content types +UPDATE user_posts +SET content_type = CASE + WHEN title ILIKE '%video%' OR title ILIKE '%youtube%' THEN 'video' + WHEN title ILIKE '%story%' THEN 'story' + WHEN title ILIKE '%image%' OR title ILIKE '%photo%' THEN 'image' + ELSE 'post' +END +WHERE content_type IS NULL; + +-- Update audience insights with sample top markets +UPDATE audience_insights +SET top_markets = '{"United States": 45, "United Kingdom": 25, "Canada": 15, "Australia": 15}' +WHERE top_markets IS NULL; + +-- Update campaign metrics with engagement data +UPDATE campaign_metrics +SET total_engagements = clicks + conversions +WHERE total_engagements IS NULL; + +-- ============================================================================ +-- SAMPLE DATA FOR DASHBOARD TESTING +-- ============================================================================ + +-- Insert additional sample campaigns with deadlines (only if brand exists) +INSERT INTO sponsorships (id, brand_id, title, description, required_audience, budget, engagement_minimum, status, deadline, created_at) +SELECT + gen_random_uuid(), + brand.id, + 'Summer Collection Launch', + 'Launch campaign for summer fashion collection', + '{"age": ["18-34"], "location": ["USA", "UK"]}', + 8000.00, + 4.5, + 'open', + NOW() + INTERVAL '15 days', + NOW() +FROM users brand +WHERE brand.username = 'brand1' +LIMIT 1; + +INSERT INTO sponsorships (id, brand_id, title, description, required_audience, budget, engagement_minimum, status, deadline, created_at) +SELECT + gen_random_uuid(), + brand.id, + 'Tech Review Series', + 'Series of tech product reviews', + '{"age": ["18-30"], "location": ["USA", "Canada"]}', + 6000.00, + 4.2, + 'open', + NOW() + INTERVAL '20 days', + NOW() +FROM users brand +WHERE brand.username = 'brand1' +LIMIT 1; + +INSERT INTO sponsorships (id, brand_id, title, description, required_audience, budget, engagement_minimum, status, deadline, created_at) +SELECT + gen_random_uuid(), + brand.id, + 'Fitness Challenge', + '30-day fitness challenge campaign', + '{"age": ["18-40"], "location": ["USA", "Australia"]}', + 4000.00, + 3.8, + 'pending', + NOW() + INTERVAL '30 days', + NOW() +FROM users brand +WHERE brand.username = 'brand1' +LIMIT 1; + +-- Insert additional payments with due dates (only if users exist) +INSERT INTO sponsorship_payments (id, creator_id, brand_id, sponsorship_id, amount, status, due_date, transaction_date) +SELECT + gen_random_uuid(), + creator.id, + brand.id, + sponsorship.id, + 1200.00, + 'pending', + NOW() + INTERVAL '5 days', + NOW() +FROM users creator, users brand, sponsorships sponsorship +WHERE creator.username = 'creator1' + AND brand.username = 'brand1' + AND sponsorship.title = 'Summer Collection Launch' +LIMIT 1; + +INSERT INTO sponsorship_payments (id, creator_id, brand_id, sponsorship_id, amount, status, due_date, transaction_date) +SELECT + gen_random_uuid(), + creator.id, + brand.id, + sponsorship.id, + 800.00, + 'pending', + NOW() + INTERVAL '3 days', + NOW() +FROM users creator, users brand, sponsorships sponsorship +WHERE creator.username = 'creator2' + AND brand.username = 'brand1' + AND sponsorship.title = 'Tech Review Series' +LIMIT 1; + +-- Insert additional posts with content types (only if users exist) +INSERT INTO user_posts (id, user_id, title, content, post_url, category, content_type, engagement_metrics, created_at) +SELECT + gen_random_uuid(), + creator.id, + 'Summer Fashion Haul Video', + 'Complete summer fashion haul video', + 'https://example.com/summer-haul', + 'Fashion', + 'video', + '{"likes": 800, "comments": 150, "shares": 80}', + NOW() +FROM users creator +WHERE creator.username = 'creator1' +LIMIT 1; + +INSERT INTO user_posts (id, user_id, title, content, post_url, category, content_type, engagement_metrics, created_at) +SELECT + gen_random_uuid(), + creator.id, + 'Tech Review Story', + 'Quick tech review in story format', + 'https://example.com/tech-story', + 'Tech', + 'story', + '{"likes": 400, "comments": 60, "shares": 30}', + NOW() +FROM users creator +WHERE creator.username = 'creator2' +LIMIT 1; + +INSERT INTO user_posts (id, user_id, title, content, post_url, category, content_type, engagement_metrics, created_at) +SELECT + gen_random_uuid(), + creator.id, + 'Fitness Motivation Image', + 'Motivational fitness post', + 'https://example.com/fitness-motivation', + 'Fitness', + 'image', + '{"likes": 600, "comments": 90, "shares": 45}', + NOW() +FROM users creator +WHERE creator.username = 'creator1' +LIMIT 1; + +-- Insert additional campaign metrics (only if campaigns exist) +INSERT INTO campaign_metrics (id, campaign_id, impressions, clicks, conversions, revenue, engagement_rate, total_engagements, recorded_at) +SELECT + gen_random_uuid(), + sponsorship.id, + 120000, + 6000, + 300, + 6000.00, + 5.0, + 6300, + NOW() +FROM sponsorships sponsorship +WHERE sponsorship.title = 'Summer Collection Launch' +LIMIT 1; + +INSERT INTO campaign_metrics (id, campaign_id, impressions, clicks, conversions, revenue, engagement_rate, total_engagements, recorded_at) +SELECT + gen_random_uuid(), + sponsorship.id, + 80000, + 4000, + 200, + 4000.00, + 5.25, + 4200, + NOW() +FROM sponsorships sponsorship +WHERE sponsorship.title = 'Tech Review Series' +LIMIT 1; + +INSERT INTO campaign_metrics (id, campaign_id, impressions, clicks, conversions, revenue, engagement_rate, total_engagements, recorded_at) +SELECT + gen_random_uuid(), + sponsorship.id, + 60000, + 3000, + 150, + 3000.00, + 5.25, + 3150, + NOW() +FROM sponsorships sponsorship +WHERE sponsorship.title = 'Fitness Challenge' +LIMIT 1; + +-- ============================================================================ +-- VERIFICATION QUERIES +-- ============================================================================ + +-- Check sponsorships with deadlines +SELECT title, deadline, status FROM sponsorships WHERE deadline IS NOT NULL; + +-- Check payments with due dates +SELECT amount, due_date, status FROM sponsorship_payments WHERE due_date IS NOT NULL; + +-- Check posts with content types +SELECT title, content_type, category FROM user_posts WHERE content_type IS NOT NULL; + +-- Check audience insights with top markets +SELECT user_id, top_markets FROM audience_insights WHERE top_markets IS NOT NULL; + +-- Check campaign metrics with engagement data +SELECT campaign_id, impressions, total_engagements, engagement_rate FROM campaign_metrics WHERE total_engagements > 0; + +-- ============================================================================ +-- ADD CREATOR MATCHES FOR ANALYTICS TESTING +-- ============================================================================ + +-- Get the brand ID +DO $$ +DECLARE + brand_id_val VARCHAR; + creator1_id_val VARCHAR; + creator2_id_val VARCHAR; +BEGIN + -- Get brand1 ID + SELECT id INTO brand_id_val FROM users WHERE username = 'brand1' LIMIT 1; + + -- Get creator IDs + SELECT id INTO creator1_id_val FROM users WHERE username = 'creator1' LIMIT 1; + SELECT id INTO creator2_id_val FROM users WHERE username = 'creator2' LIMIT 1; + + -- Insert creator matches if they don't exist + IF brand_id_val IS NOT NULL AND creator1_id_val IS NOT NULL THEN + INSERT INTO creator_matches (id, brand_id, creator_id, match_score, matched_at) + SELECT + gen_random_uuid()::text, + brand_id_val, + creator1_id_val, + 0.95, + NOW() + WHERE NOT EXISTS ( + SELECT 1 FROM creator_matches + WHERE brand_id = brand_id_val AND creator_id = creator1_id_val + ); + END IF; + + IF brand_id_val IS NOT NULL AND creator2_id_val IS NOT NULL THEN + INSERT INTO creator_matches (id, brand_id, creator_id, match_score, matched_at) + SELECT + gen_random_uuid()::text, + brand_id_val, + creator2_id_val, + 0.87, + NOW() + WHERE NOT EXISTS ( + SELECT 1 FROM creator_matches + WHERE brand_id = brand_id_val AND creator_id = creator2_id_val + ); + END IF; + + RAISE NOTICE 'Creator matches added for brand: %', brand_id_val; +END $$; + +-- Verify the creator matches +SELECT + cm.id, + b.username as brand_username, + c.username as creator_username, + cm.match_score, + cm.matched_at +FROM creator_matches cm +JOIN users b ON cm.brand_id = b.id +JOIN users c ON cm.creator_id = c.id +WHERE b.username = 'brand1'; + +-- ============================================================================ +-- UPDATE AUDIENCE INSIGHTS WITH BETTER GEOGRAPHIC DATA +-- ============================================================================ + +-- Update existing audience insights with top_markets data +UPDATE audience_insights +SET top_markets = '{"United States": 45, "United Kingdom": 25, "Canada": 15, "Australia": 15}' +WHERE user_id IN (SELECT id FROM users WHERE username = 'creator1'); + +UPDATE audience_insights +SET top_markets = '{"India": 40, "United States": 30, "Canada": 20, "United Kingdom": 10}' +WHERE user_id IN (SELECT id FROM users WHERE username = 'creator2'); + +-- Add more diverse audience insights for better analytics +INSERT INTO audience_insights (id, user_id, audience_age_group, audience_location, engagement_rate, average_views, time_of_attention, price_expectation, top_markets, created_at) +SELECT + gen_random_uuid(), + u.id, + '{"18-24": 60, "25-34": 40}', + '{"USA": 50, "UK": 30, "Canada": 20}', + 4.2, + 8500, + 110, + 480.00, + '{"United States": 50, "United Kingdom": 30, "Canada": 20}', + NOW() +FROM users u +WHERE u.username = 'brand1' +AND NOT EXISTS ( + SELECT 1 FROM audience_insights WHERE user_id = u.id +); + +-- Verify the updates +SELECT + ai.user_id, + u.username, + ai.top_markets, + ai.engagement_rate +FROM audience_insights ai +JOIN users u ON ai.user_id = u.id +WHERE u.username IN ('creator1', 'creator2', 'brand1'); + +-- ============================================================================ +-- ENHANCED CONTRACTS DATABASE SCHEMA +-- ============================================================================ + +-- ============================================================================ +-- 1. ENHANCE EXISTING CONTRACTS TABLE +-- ============================================================================ + +-- Add missing columns to existing contracts table +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS contract_title TEXT; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS contract_type TEXT DEFAULT 'one-time'; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS terms_and_conditions JSONB; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS payment_terms JSONB; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS deliverables JSONB; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS start_date DATE; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS end_date DATE; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS total_budget NUMERIC(10,2); +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS payment_schedule JSONB; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS legal_compliance JSONB; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS signature_data JSONB; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS version_history JSONB; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP WITH TIME ZONE DEFAULT now(); + +-- ============================================================================ +-- 2. CONTRACT TEMPLATES TABLE +-- ============================================================================ + +CREATE TABLE IF NOT EXISTS contract_templates ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + template_name TEXT NOT NULL, + template_type TEXT NOT NULL, -- 'one-time', 'ongoing', 'performance-based' + industry TEXT, + terms_template JSONB, + payment_terms_template JSONB, + deliverables_template JSONB, + created_by VARCHAR REFERENCES users(id) ON DELETE SET NULL, + is_public BOOLEAN DEFAULT false, + is_active BOOLEAN DEFAULT true, + created_at TIMESTAMP WITH TIME ZONE DEFAULT now(), + updated_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- ============================================================================ +-- 3. CONTRACT MILESTONES TABLE +-- ============================================================================ + +CREATE TABLE IF NOT EXISTS contract_milestones ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + contract_id VARCHAR REFERENCES contracts(id) ON DELETE CASCADE, + milestone_name TEXT NOT NULL, + description TEXT, + due_date DATE NOT NULL, + payment_amount NUMERIC(10,2) NOT NULL, + status TEXT DEFAULT 'pending', -- pending, completed, overdue, cancelled + completion_criteria JSONB, + completed_at TIMESTAMP WITH TIME ZONE, + created_at TIMESTAMP WITH TIME ZONE DEFAULT now(), + updated_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- ============================================================================ +-- 4. CONTRACT DELIVERABLES TABLE +-- ============================================================================ + +CREATE TABLE IF NOT EXISTS contract_deliverables ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + contract_id VARCHAR REFERENCES contracts(id) ON DELETE CASCADE, + deliverable_type TEXT NOT NULL, -- 'post', 'video', 'story', 'review', 'live' + description TEXT, + platform TEXT NOT NULL, -- 'instagram', 'youtube', 'tiktok', 'twitter', 'facebook' + requirements JSONB, + due_date DATE NOT NULL, + status TEXT DEFAULT 'pending', -- pending, in_progress, submitted, approved, rejected + content_url TEXT, + approval_status TEXT DEFAULT 'pending', -- pending, approved, rejected, needs_revision + approval_notes TEXT, + submitted_at TIMESTAMP WITH TIME ZONE, + approved_at TIMESTAMP WITH TIME ZONE, + created_at TIMESTAMP WITH TIME ZONE DEFAULT now(), + updated_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- ============================================================================ +-- 5. CONTRACT PAYMENTS TABLE +-- ============================================================================ + +CREATE TABLE IF NOT EXISTS contract_payments ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + contract_id VARCHAR REFERENCES contracts(id) ON DELETE CASCADE, + milestone_id VARCHAR REFERENCES contract_milestones(id) ON DELETE SET NULL, + amount NUMERIC(10,2) NOT NULL, + payment_type TEXT NOT NULL, -- 'advance', 'milestone', 'final', 'bonus' + status TEXT DEFAULT 'pending', -- pending, paid, overdue, cancelled, failed + due_date DATE NOT NULL, + paid_date TIMESTAMP WITH TIME ZONE, + payment_method TEXT, -- 'bank_transfer', 'paypal', 'stripe', 'escrow' + transaction_id TEXT, + payment_notes TEXT, + created_at TIMESTAMP WITH TIME ZONE DEFAULT now(), + updated_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- ============================================================================ +-- 6. CONTRACT COMMENTS/NEGOTIATIONS TABLE +-- ============================================================================ + +CREATE TABLE IF NOT EXISTS contract_comments ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + contract_id VARCHAR REFERENCES contracts(id) ON DELETE CASCADE, + user_id VARCHAR REFERENCES users(id) ON DELETE CASCADE, + comment TEXT NOT NULL, + comment_type TEXT DEFAULT 'general', -- 'negotiation', 'approval', 'general', 'revision' + is_internal BOOLEAN DEFAULT false, + parent_comment_id VARCHAR REFERENCES contract_comments(id) ON DELETE CASCADE, + created_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- ============================================================================ +-- 7. CONTRACT ANALYTICS TABLE +-- ============================================================================ + +CREATE TABLE IF NOT EXISTS contract_analytics ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + contract_id VARCHAR REFERENCES contracts(id) ON DELETE CASCADE, + performance_metrics JSONB, -- engagement_rate, reach, impressions, clicks + engagement_data JSONB, -- likes, comments, shares, saves + revenue_generated NUMERIC(10,2) DEFAULT 0, + roi_percentage FLOAT DEFAULT 0, + cost_per_engagement NUMERIC(10,2) DEFAULT 0, + cost_per_click NUMERIC(10,2) DEFAULT 0, + recorded_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- ============================================================================ +-- 8. CONTRACT NOTIFICATIONS TABLE +-- ============================================================================ + +CREATE TABLE IF NOT EXISTS contract_notifications ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + contract_id VARCHAR REFERENCES contracts(id) ON DELETE CASCADE, + user_id VARCHAR REFERENCES users(id) ON DELETE CASCADE, + notification_type TEXT NOT NULL, -- 'milestone_due', 'payment_received', 'deliverable_submitted', 'contract_expiring' + title TEXT NOT NULL, + message TEXT NOT NULL, + is_read BOOLEAN DEFAULT false, + created_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- ============================================================================ +-- SAMPLE DATA FOR CONTRACTS TABLES +-- ============================================================================ + +-- Get existing user IDs for sample data +DO $$ +DECLARE + brand1_id_val VARCHAR; + creator1_id_val VARCHAR; + creator2_id_val VARCHAR; + sponsorship1_id_val VARCHAR; + contract1_id_val VARCHAR; + contract2_id_val VARCHAR; + contract3_id_val VARCHAR; +BEGIN + -- Get user IDs + SELECT id INTO brand1_id_val FROM users WHERE username = 'brand1' LIMIT 1; + SELECT id INTO creator1_id_val FROM users WHERE username = 'creator1' LIMIT 1; + SELECT id INTO creator2_id_val FROM users WHERE username = 'creator2' LIMIT 1; + SELECT id INTO sponsorship1_id_val FROM sponsorships WHERE title = 'Tech Sponsorship' LIMIT 1; + + -- Insert sample contracts + INSERT INTO contracts (id, sponsorship_id, creator_id, brand_id, contract_title, contract_type, terms_and_conditions, payment_terms, deliverables, start_date, end_date, total_budget, payment_schedule, legal_compliance, status, created_at) + VALUES + (gen_random_uuid()::text, sponsorship1_id_val, creator1_id_val, brand1_id_val, 'Tech Watch Campaign Contract', 'one-time', + '{"content_guidelines": "Must mention product features", "disclosure_requirements": "Clear FTC compliance"}', + '{"payment_schedule": "50% upfront, 50% on completion", "late_fees": "5% per week"}', + '{"deliverables": ["2 Instagram posts", "1 YouTube video", "3 TikTok videos"]}', + '2024-01-15', '2024-02-15', 2500.00, + '{"advance": 1250.00, "final": 1250.00}', + '{"ftc_compliance": true, "disclosure_required": true}', + 'signed', NOW()), + + (gen_random_uuid()::text, NULL, creator2_id_val, brand1_id_val, 'Fashion Collaboration Contract', 'ongoing', + '{"content_guidelines": "Fashion-forward styling", "brand_guidelines": "Must use brand hashtags"}', + '{"payment_schedule": "Monthly payments", "performance_bonus": "10% for high engagement"}', + '{"deliverables": ["4 Instagram posts per month", "2 Stories per week", "1 Reel per month"]}', + '2024-01-01', '2024-06-30', 6000.00, + '{"monthly": 1000.00}', + '{"ftc_compliance": true, "disclosure_required": true}', + 'active', NOW()), + + (gen_random_uuid()::text, NULL, creator1_id_val, brand1_id_val, 'Gaming Setup Review Contract', 'one-time', + '{"content_guidelines": "Honest review required", "disclosure_requirements": "Sponsored content disclosure"}', + '{"payment_schedule": "100% on completion", "bonus": "200 for high engagement"}', + '{"deliverables": ["1 detailed review video", "2 social media posts", "1 blog post"]}', + '2024-02-01', '2024-03-01', 1500.00, + '{"final": 1500.00}', + '{"ftc_compliance": true, "disclosure_required": true}', + 'draft', NOW()) + RETURNING id INTO contract1_id_val; + + -- Get contract IDs for further data insertion + SELECT id INTO contract1_id_val FROM contracts WHERE contract_title = 'Tech Watch Campaign Contract' LIMIT 1; + SELECT id INTO contract2_id_val FROM contracts WHERE contract_title = 'Fashion Collaboration Contract' LIMIT 1; + SELECT id INTO contract3_id_val FROM contracts WHERE contract_title = 'Gaming Setup Review Contract' LIMIT 1; + + -- Insert contract templates + INSERT INTO contract_templates (id, template_name, template_type, industry, terms_template, payment_terms_template, deliverables_template, created_by, is_public, is_active, created_at) + VALUES + (gen_random_uuid()::text, 'Standard Influencer Contract', 'one-time', 'General', + '{"content_guidelines": "Brand guidelines must be followed", "disclosure_requirements": "FTC compliance required"}', + '{"payment_schedule": "50% upfront, 50% on completion", "late_fees": "5% per week"}', + '{"deliverables": ["2-3 social media posts", "1 video content", "Stories coverage"]}', + brand1_id_val, true, true, NOW()), + + (gen_random_uuid()::text, 'Ongoing Collaboration Contract', 'ongoing', 'Fashion', + '{"content_guidelines": "Fashion-forward content", "brand_guidelines": "Use brand hashtags"}', + '{"payment_schedule": "Monthly payments", "performance_bonus": "10% for high engagement"}', + '{"deliverables": ["4 posts per month", "2 stories per week", "1 reel per month"]}', + brand1_id_val, true, true, NOW()), + + (gen_random_uuid()::text, 'Tech Review Contract', 'one-time', 'Technology', + '{"content_guidelines": "Honest review required", "disclosure_requirements": "Sponsored content disclosure"}', + '{"payment_schedule": "100% on completion", "bonus": "200 for high engagement"}', + '{"deliverables": ["1 review video", "2 social posts", "1 blog post"]}', + brand1_id_val, true, true, NOW()); + + -- Insert contract milestones + INSERT INTO contract_milestones (id, contract_id, milestone_name, description, due_date, payment_amount, status, completion_criteria, created_at) + VALUES + (gen_random_uuid()::text, contract1_id_val, 'Content Creation', 'Create initial content drafts', '2024-01-25', 1250.00, 'completed', + '{"drafts_submitted": true, "brand_approval": true}', NOW()), + + (gen_random_uuid()::text, contract1_id_val, 'Content Publication', 'Publish all content across platforms', '2024-02-10', 1250.00, 'pending', + '{"all_posts_published": true, "engagement_metrics": "minimum 5% engagement"}', NOW()), + + (gen_random_uuid()::text, contract2_id_val, 'January Content', 'Complete January content deliverables', '2024-01-31', 1000.00, 'completed', + '{"4_posts_published": true, "stories_completed": true}', NOW()), + + (gen_random_uuid()::text, contract2_id_val, 'February Content', 'Complete February content deliverables', '2024-02-29', 1000.00, 'in_progress', + '{"4_posts_published": true, "stories_completed": true}', NOW()); + + -- Insert contract deliverables + INSERT INTO contract_deliverables (id, contract_id, deliverable_type, description, platform, requirements, due_date, status, content_url, approval_status, created_at) + VALUES + (gen_random_uuid()::text, contract1_id_val, 'post', 'Instagram post featuring the tech watch', 'instagram', + '{"image_requirements": "High quality", "caption_requirements": "Include product features", "hashtags": ["#tech", "#watch"]}', + '2024-01-30', 'approved', 'https://instagram.com/p/example1', 'approved', NOW()), + + (gen_random_uuid()::text, contract1_id_val, 'video', 'YouTube review video of the tech watch', 'youtube', + '{"video_length": "5-10 minutes", "content_requirements": "Honest review with pros and cons", "thumbnail_requirements": "Eye-catching design"}', + '2024-02-05', 'submitted', 'https://youtube.com/watch?v=example1', 'pending', NOW()), + + (gen_random_uuid()::text, contract1_id_val, 'story', 'Instagram stories showcasing the watch', 'instagram', + '{"story_count": "3-5 stories", "content_requirements": "Behind the scenes and product features"}', + '2024-02-08', 'in_progress', NULL, 'pending', NOW()), + + (gen_random_uuid()::text, contract2_id_val, 'post', 'Fashion collaboration post', 'instagram', + '{"image_requirements": "Fashion-forward styling", "caption_requirements": "Include brand hashtags"}', + '2024-01-15', 'approved', 'https://instagram.com/p/example2', 'approved', NOW()), + + (gen_random_uuid()::text, contract2_id_val, 'story', 'Fashion stories', 'instagram', + '{"story_count": "2 stories", "content_requirements": "Styling tips and product features"}', + '2024-01-20', 'approved', 'https://instagram.com/stories/example2', 'approved', NOW()); + + -- Insert contract payments + INSERT INTO contract_payments (id, contract_id, milestone_id, amount, payment_type, status, due_date, paid_date, payment_method, transaction_id, payment_notes, created_at) + VALUES + (gen_random_uuid()::text, contract1_id_val, (SELECT id FROM contract_milestones WHERE milestone_name = 'Content Creation' LIMIT 1), + 1250.00, 'advance', 'paid', '2024-01-15', '2024-01-15', 'bank_transfer', 'TXN001', 'Advance payment for content creation', NOW()), + + (gen_random_uuid()::text, contract1_id_val, (SELECT id FROM contract_milestones WHERE milestone_name = 'Content Publication' LIMIT 1), + 1250.00, 'final', 'pending', '2024-02-10', NULL, NULL, NULL, 'Final payment upon completion', NOW()), + + (gen_random_uuid()::text, contract2_id_val, (SELECT id FROM contract_milestones WHERE milestone_name = 'January Content' LIMIT 1), + 1000.00, 'milestone', 'paid', '2024-01-31', '2024-01-31', 'paypal', 'TXN002', 'January content payment', NOW()), + + (gen_random_uuid()::text, contract2_id_val, (SELECT id FROM contract_milestones WHERE milestone_name = 'February Content' LIMIT 1), + 1000.00, 'milestone', 'pending', '2024-02-29', NULL, NULL, NULL, 'February content payment', NOW()); + + -- Insert contract comments + INSERT INTO contract_comments (id, contract_id, user_id, comment, comment_type, is_internal, created_at) + VALUES + (gen_random_uuid()::text, contract1_id_val, brand1_id_val, 'Great initial content! Please ensure FTC disclosure is clearly visible.', 'approval', false, NOW()), + + (gen_random_uuid()::text, contract1_id_val, creator1_id_val, 'Thank you! I\'ll make sure the disclosure is prominent in all content.', 'general', false, NOW()), + + (gen_random_uuid()::text, contract2_id_val, brand1_id_val, 'Love the fashion content! The engagement is exceeding expectations.', 'general', false, NOW()), + + (gen_random_uuid()::text, contract2_id_val, creator2_id_val, 'Thank you! I\'m excited to continue this collaboration.', 'general', false, NOW()), + + (gen_random_uuid()::text, contract3_id_val, brand1_id_val, 'Please review the gaming setup thoroughly and provide honest feedback.', 'negotiation', false, NOW()); + + -- Insert contract analytics + INSERT INTO contract_analytics (id, contract_id, performance_metrics, engagement_data, revenue_generated, roi_percentage, cost_per_engagement, cost_per_click, recorded_at) + VALUES + (gen_random_uuid()::text, contract1_id_val, + '{"engagement_rate": 6.2, "reach": 15000, "impressions": 25000, "clicks": 1200}', + '{"likes": 1800, "comments": 450, "shares": 200, "saves": 300}', + 3500.00, 140.0, 0.83, 2.08, NOW()), + + (gen_random_uuid()::text, contract2_id_val, + '{"engagement_rate": 8.5, "reach": 22000, "impressions": 35000, "clicks": 1800}', + '{"likes": 2800, "comments": 600, "shares": 350, "saves": 450}', + 4800.00, 180.0, 0.71, 1.78, NOW()), + + (gen_random_uuid()::text, contract3_id_val, + '{"engagement_rate": 4.8, "reach": 8000, "impressions": 12000, "clicks": 600}', + '{"likes": 900, "comments": 200, "shares": 100, "saves": 150}', + 1200.00, 80.0, 1.25, 2.50, NOW()); + + -- Insert contract notifications + INSERT INTO contract_notifications (id, contract_id, user_id, notification_type, title, message, is_read, created_at) + VALUES + (gen_random_uuid()::text, contract1_id_val, creator1_id_val, 'milestone_due', 'Milestone Due', 'Content Publication milestone is due in 3 days', false, NOW()), + + (gen_random_uuid()::text, contract1_id_val, brand1_id_val, 'deliverable_submitted', 'Content Submitted', 'New content has been submitted for review', false, NOW()), + + (gen_random_uuid()::text, contract2_id_val, creator2_id_val, 'payment_received', 'Payment Received', 'January content payment has been processed', true, NOW()), + + (gen_random_uuid()::text, contract2_id_val, brand1_id_val, 'milestone_due', 'Milestone Due', 'February Content milestone is due in 5 days', false, NOW()), + + (gen_random_uuid()::text, contract3_id_val, creator1_id_val, 'contract_expiring', 'Contract Expiring', 'Gaming Setup Review contract expires in 10 days', false, NOW()); + + RAISE NOTICE 'Sample contract data inserted successfully'; +END $$; + +-- Verify the sample data +SELECT + c.contract_title, + c.status, + c.total_budget, + u1.username as creator, + u2.username as brand +FROM contracts c +JOIN users u1 ON c.creator_id = u1.id +JOIN users u2 ON c.brand_id = u2.id; + +SELECT + ct.template_name, + ct.template_type, + ct.industry, + u.username as created_by +FROM contract_templates ct +LEFT JOIN users u ON ct.created_by = u.id; + +SELECT + cm.milestone_name, + cm.status, + cm.payment_amount, + c.contract_title +FROM contract_milestones cm +JOIN contracts c ON cm.contract_id = c.id; + +SELECT + cd.deliverable_type, + cd.platform, + cd.status, + cd.approval_status, + c.contract_title +FROM contract_deliverables cd +JOIN contracts c ON cd.contract_id = c.id; + +SELECT + cp.amount, + cp.payment_type, + cp.status, + c.contract_title +FROM contract_payments cp +JOIN contracts c ON cp.contract_id = c.id; + +SELECT + cc.comment, + cc.comment_type, + u.username as user, + c.contract_title +FROM contract_comments cc +JOIN users u ON cc.user_id = u.id +JOIN contracts c ON cc.contract_id = c.id; + +SELECT + ca.revenue_generated, + ca.roi_percentage, + c.contract_title +FROM contract_analytics ca +JOIN contracts c ON ca.contract_id = c.id; + +SELECT + cn.notification_type, + cn.title, + cn.is_read, + c.contract_title +FROM contract_notifications cn +JOIN contracts c ON cn.contract_id = c.id; + + +-- Add to contracts table for self-learning pricing +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS brand_satisfaction_score INTEGER; -- 1-10 scale +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS roi_achieved DECIMAL(5,2); -- Percentage achieved +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS repeat_business BOOLEAN DEFAULT false; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS price_negotiation_history JSONB; -- Track price changes +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS campaign_success_metrics JSONB; -- Final performance data + +-- Add to contracts table for better similarity matching +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS creator_followers INTEGER; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS creator_engagement_rate DECIMAL(5,4); +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS content_type VARCHAR(50); -- 'video', 'post', 'story', 'live' +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS campaign_type VARCHAR(50); -- 'product_launch', 'brand_awareness', 'sales' +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS platform VARCHAR(50); -- 'instagram', 'youtube', 'tiktok', 'twitter' +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS duration_weeks INTEGER; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS exclusivity_level VARCHAR(50); -- 'none', 'platform', 'category', 'full' + +-- Add to contracts table for market context +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS market_trend_score DECIMAL(3,2); -- 0-1 scale +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS seasonal_factor DECIMAL(3,2); -- 0-1 scale +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS industry_benchmark_rate DECIMAL(5,2); -- Industry average +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS competitor_pricing JSONB; -- Similar competitor rates + +-- Create new table for detailed pricing feedback +CREATE TABLE IF NOT EXISTS pricing_feedback ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + contract_id VARCHAR REFERENCES contracts(id) ON DELETE CASCADE, + recommended_price DECIMAL(10,2), + actual_price DECIMAL(10,2), + price_accuracy_score INTEGER, -- 1-10 scale + market_conditions TEXT, + feedback_notes TEXT, + created_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- Create table to store AI recommendations +CREATE TABLE IF NOT EXISTS pricing_recommendations ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + contract_id VARCHAR REFERENCES contracts(id) ON DELETE CASCADE, + recommended_price DECIMAL(10,2), + confidence_score DECIMAL(3,2), -- 0-1 scale + reasoning JSONB, -- AI explanation + similar_contracts_used JSONB, -- IDs of similar contracts + market_factors JSONB, -- Market conditions considered + created_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- Add sample data for AI pricing optimization system +-- This script populates the contracts table with realistic data for testing + +-- Update existing contracts with creator metrics and learning fields +UPDATE contracts +SET + creator_followers = CASE + WHEN creator_id = (SELECT id FROM users WHERE username = 'creator1') THEN 25000 + WHEN creator_id = (SELECT id FROM users WHERE username = 'creator2') THEN 15000 + ELSE 10000 + END, + creator_engagement_rate = CASE + WHEN creator_id = (SELECT id FROM users WHERE username = 'creator1') THEN 4.5 + WHEN creator_id = (SELECT id FROM users WHERE username = 'creator2') THEN 3.8 + ELSE 3.2 + END, + content_type = CASE + WHEN id = (SELECT id FROM contracts WHERE contract_url LIKE '%tech%') THEN 'video' + WHEN id = (SELECT id FROM contracts WHERE contract_url LIKE '%fashion%') THEN 'post' + ELSE 'video' + END, + campaign_type = CASE + WHEN id = (SELECT id FROM contracts WHERE contract_url LIKE '%tech%') THEN 'product_launch' + WHEN id = (SELECT id FROM contracts WHERE contract_url LIKE '%fashion%') THEN 'brand_awareness' + ELSE 'sales' + END, + platform = CASE + WHEN id = (SELECT id FROM contracts WHERE contract_url LIKE '%tech%') THEN 'youtube' + WHEN id = (SELECT id FROM contracts WHERE contract_url LIKE '%fashion%') THEN 'instagram' + ELSE 'youtube' + END, + duration_weeks = CASE + WHEN id = (SELECT id FROM contracts WHERE contract_url LIKE '%tech%') THEN 4 + WHEN id = (SELECT id FROM contracts WHERE contract_url LIKE '%fashion%') THEN 2 + ELSE 3 + END, + exclusivity_level = 'none', + brand_satisfaction_score = CASE + WHEN status = 'signed' THEN 8 + ELSE NULL + END, + roi_achieved = CASE + WHEN status = 'signed' THEN 85.5 + ELSE NULL + END, + repeat_business = CASE + WHEN status = 'signed' THEN true + ELSE false + END, + price_negotiation_history = CASE + WHEN status = 'signed' THEN '{"initial_price": 450, "final_price": 500, "negotiation_rounds": 2}'::jsonb + ELSE NULL + END, + campaign_success_metrics = CASE + WHEN status = 'signed' THEN '{"impressions": 50000, "clicks": 2500, "conversions": 125, "engagement_rate": 4.5}'::jsonb + ELSE NULL + END +WHERE id IN (SELECT id FROM contracts LIMIT 10); + +-- Insert additional sample contracts for better pricing analysis +INSERT INTO contracts ( + id, sponsorship_id, creator_id, brand_id, contract_url, status, + total_budget, creator_followers, creator_engagement_rate, content_type, + campaign_type, platform, duration_weeks, exclusivity_level, + brand_satisfaction_score, roi_achieved, repeat_business, + price_negotiation_history, campaign_success_metrics, created_at +) VALUES +-- High-tier creator contracts +(gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Tech Sponsorship'), + (SELECT id FROM users WHERE username = 'creator1'), (SELECT id FROM users WHERE username = 'brand1'), + 'https://contracts.example.com/tech-video-1.pdf', 'signed', 2500.00, 50000, 6.2, 'video', + 'product_launch', 'youtube', 6, 'platform', 9, 120.5, true, + '{"initial_price": 2000, "final_price": 2500, "negotiation_rounds": 3}'::jsonb, + '{"impressions": 120000, "clicks": 6000, "conversions": 300, "engagement_rate": 6.2}'::jsonb, + NOW() - INTERVAL '30 days'), + +(gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Fashion Sponsorship'), + (SELECT id FROM users WHERE username = 'creator2'), (SELECT id FROM users WHERE username = 'brand1'), + 'https://contracts.example.com/fashion-post-1.pdf', 'signed', 1800.00, 35000, 5.8, 'post', + 'brand_awareness', 'instagram', 4, 'none', 8, 95.2, true, + '{"initial_price": 1500, "final_price": 1800, "negotiation_rounds": 2}'::jsonb, + '{"impressions": 80000, "clicks": 4000, "conversions": 200, "engagement_rate": 5.8}'::jsonb, + NOW() - INTERVAL '45 days'), + +-- Mid-tier creator contracts +(gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Gaming Sponsorship'), + (SELECT id FROM users WHERE username = 'creator1'), (SELECT id FROM users WHERE username = 'brand1'), + 'https://contracts.example.com/gaming-live-1.pdf', 'signed', 1200.00, 20000, 4.1, 'live', + 'sales', 'youtube', 3, 'none', 7, 78.3, false, + '{"initial_price": 1000, "final_price": 1200, "negotiation_rounds": 1}'::jsonb, + '{"impressions": 45000, "clicks": 2250, "conversions": 112, "engagement_rate": 4.1}'::jsonb, + NOW() - INTERVAL '60 days'), + +(gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Tech Sponsorship'), + (SELECT id FROM users WHERE username = 'creator2'), (SELECT id FROM users WHERE username = 'brand1'), + 'https://contracts.example.com/tech-review-1.pdf', 'signed', 900.00, 12000, 3.5, 'review', + 'product_launch', 'youtube', 2, 'none', 6, 65.8, false, + '{"initial_price": 800, "final_price": 900, "negotiation_rounds": 1}'::jsonb, + '{"impressions": 30000, "clicks": 1500, "conversions": 75, "engagement_rate": 3.5}'::jsonb, + NOW() - INTERVAL '75 days'), + +-- Low-tier creator contracts +(gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Fashion Sponsorship'), + (SELECT id FROM users WHERE username = 'creator1'), (SELECT id FROM users WHERE username = 'brand1'), + 'https://contracts.example.com/fashion-story-1.pdf', 'signed', 600.00, 8000, 2.8, 'story', + 'brand_awareness', 'instagram', 1, 'none', 5, 45.2, false, + '{"initial_price": 500, "final_price": 600, "negotiation_rounds": 1}'::jsonb, + '{"impressions": 20000, "clicks": 1000, "conversions": 50, "engagement_rate": 2.8}'::jsonb, + NOW() - INTERVAL '90 days'), + +(gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Gaming Sponsorship'), + (SELECT id FROM users WHERE username = 'creator2'), (SELECT id FROM users WHERE username = 'brand1'), + 'https://contracts.example.com/gaming-post-1.pdf', 'signed', 400.00, 5000, 2.1, 'post', + 'sales', 'instagram', 1, 'none', 4, 32.5, false, + '{"initial_price": 350, "final_price": 400, "negotiation_rounds": 1}'::jsonb, + '{"impressions": 15000, "clicks": 750, "conversions": 37, "engagement_rate": 2.1}'::jsonb, + NOW() - INTERVAL '105 days'), + +-- High-tier creator with different content types +(gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Tech Sponsorship'), + (SELECT id FROM users WHERE username = 'creator1'), (SELECT id FROM users WHERE username = 'brand1'), + 'https://contracts.example.com/tech-tutorial-1.pdf', 'signed', 3000.00, 75000, 7.5, 'tutorial', + 'product_launch', 'youtube', 8, 'category', 10, 150.8, true, + '{"initial_price": 2500, "final_price": 3000, "negotiation_rounds": 4}'::jsonb, + '{"impressions": 180000, "clicks": 9000, "conversions": 450, "engagement_rate": 7.5}'::jsonb, + NOW() - INTERVAL '15 days'), + +(gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Fashion Sponsorship'), + (SELECT id FROM users WHERE username = 'creator2'), (SELECT id FROM users WHERE username = 'brand1'), + 'https://contracts.example.com/fashion-video-1.pdf', 'signed', 2200.00, 45000, 6.8, 'video', + 'brand_awareness', 'instagram', 5, 'platform', 9, 110.3, true, + '{"initial_price": 1800, "final_price": 2200, "negotiation_rounds": 3}'::jsonb, + '{"impressions": 100000, "clicks": 5000, "conversions": 250, "engagement_rate": 6.8}'::jsonb, + NOW() - INTERVAL '25 days'); + +-- Insert sample pricing feedback data +INSERT INTO pricing_feedback ( + contract_id, recommended_price, actual_price, price_accuracy_score, + market_conditions, feedback_notes, created_at +) VALUES +((SELECT id FROM contracts WHERE total_budget = 2500.00 LIMIT 1), 2400.00, 2500.00, 8, + 'normal', 'Good recommendation, slight underestimation', NOW() - INTERVAL '25 days'), + +((SELECT id FROM contracts WHERE total_budget = 1800.00 LIMIT 1), 1750.00, 1800.00, 9, + 'normal', 'Very accurate recommendation', NOW() - INTERVAL '40 days'), + +((SELECT id FROM contracts WHERE total_budget = 1200.00 LIMIT 1), 1100.00, 1200.00, 7, + 'normal', 'Underestimated by about 9%', NOW() - INTERVAL '55 days'), + +((SELECT id FROM contracts WHERE total_budget = 900.00 LIMIT 1), 950.00, 900.00, 8, + 'normal', 'Slightly overestimated, but close', NOW() - INTERVAL '70 days'), + +((SELECT id FROM contracts WHERE total_budget = 600.00 LIMIT 1), 550.00, 600.00, 6, + 'normal', 'Underestimated by about 8%', NOW() - INTERVAL '85 days'), + +((SELECT id FROM contracts WHERE total_budget = 400.00 LIMIT 1), 450.00, 400.00, 7, + 'normal', 'Overestimated by about 12%', NOW() - INTERVAL '100 days'), + +((SELECT id FROM contracts WHERE total_budget = 3000.00 LIMIT 1), 2800.00, 3000.00, 8, + 'normal', 'Good recommendation for high-tier creator', NOW() - INTERVAL '10 days'), + +((SELECT id FROM contracts WHERE total_budget = 2200.00 LIMIT 1), 2100.00, 2200.00, 9, + 'normal', 'Very accurate for mid-tier creator', NOW() - INTERVAL '20 days'); + +-- Insert sample pricing recommendations +INSERT INTO pricing_recommendations ( + contract_id, recommended_price, confidence_score, reasoning, + similar_contracts_used, market_factors, created_at +) VALUES +((SELECT id FROM contracts WHERE total_budget = 2500.00 LIMIT 1), 2400.00, 0.85, + '{"explanation": "Based on 3 similar contracts with 78% average similarity", "price_range": "$1800 - $3000", "adjustment": "Price increased by 15% based on market factors", "most_similar": "$2200 (82% match)"}'::jsonb, + '{"contract_ids": ["contract1", "contract2", "contract3"], "similarity_scores": [0.82, 0.75, 0.78]}'::jsonb, + '{"base_price": 2100, "adjustment_factor": 1.15, "follower_multiplier": 1.2, "engagement_multiplier": 1.2, "content_type_multiplier": 1.5, "platform_multiplier": 1.3, "duration_multiplier": 1.1, "exclusivity_multiplier": 1.2}'::jsonb, + NOW() - INTERVAL '30 days'), + +((SELECT id FROM contracts WHERE total_budget = 1800.00 LIMIT 1), 1750.00, 0.92, + '{"explanation": "Based on 4 similar contracts with 85% average similarity", "price_range": "$1200 - $2200", "adjustment": "Price decreased by 3% based on market factors", "most_similar": "$1800 (88% match)"}'::jsonb, + '{"contract_ids": ["contract4", "contract5", "contract6", "contract7"], "similarity_scores": [0.88, 0.82, 0.85, 0.83]}'::jsonb, + '{"base_price": 1800, "adjustment_factor": 0.97, "follower_multiplier": 1.0, "engagement_multiplier": 1.1, "content_type_multiplier": 1.0, "platform_multiplier": 1.0, "duration_multiplier": 1.0, "exclusivity_multiplier": 1.0}'::jsonb, + NOW() - INTERVAL '45 days'); + +-- Update some contracts with different platforms and content types for variety +UPDATE contracts +SET + platform = CASE + WHEN content_type = 'video' THEN 'youtube' + WHEN content_type = 'post' THEN 'instagram' + WHEN content_type = 'story' THEN 'instagram' + WHEN content_type = 'live' THEN 'youtube' + WHEN content_type = 'review' THEN 'youtube' + WHEN content_type = 'tutorial' THEN 'youtube' + ELSE 'instagram' + END +WHERE platform IS NULL; + +-- Add some TikTok contracts for platform diversity +INSERT INTO contracts ( + id, sponsorship_id, creator_id, brand_id, contract_url, status, + total_budget, creator_followers, creator_engagement_rate, content_type, + campaign_type, platform, duration_weeks, exclusivity_level, + brand_satisfaction_score, roi_achieved, repeat_business, + price_negotiation_history, campaign_success_metrics, created_at +) VALUES +(gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Fashion Sponsorship'), + (SELECT id FROM users WHERE username = 'creator1'), (SELECT id FROM users WHERE username = 'brand1'), + 'https://contracts.example.com/fashion-tiktok-1.pdf', 'signed', 800.00, 18000, 4.2, 'video', + 'brand_awareness', 'tiktok', 2, 'none', 7, 68.5, false, + '{"initial_price": 700, "final_price": 800, "negotiation_rounds": 1}'::jsonb, + '{"impressions": 35000, "clicks": 1750, "conversions": 87, "engagement_rate": 4.2}'::jsonb, + NOW() - INTERVAL '50 days'), + +(gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Gaming Sponsorship'), + (SELECT id FROM users WHERE username = 'creator2'), (SELECT id FROM users WHERE username = 'brand1'), + 'https://contracts.example.com/gaming-tiktok-1.pdf', 'signed', 600.00, 12000, 3.8, 'video', + 'sales', 'tiktok', 1, 'none', 6, 52.3, false, + '{"initial_price": 550, "final_price": 600, "negotiation_rounds": 1}'::jsonb, + '{"impressions": 25000, "clicks": 1250, "conversions": 62, "engagement_rate": 3.8}'::jsonb, + NOW() - INTERVAL '65 days'); + +-- Add some Twitter contracts for more platform diversity +INSERT INTO contracts ( + id, sponsorship_id, creator_id, brand_id, contract_url, status, + total_budget, creator_followers, creator_engagement_rate, content_type, + campaign_type, platform, duration_weeks, exclusivity_level, + brand_satisfaction_score, roi_achieved, repeat_business, + price_negotiation_history, campaign_success_metrics, created_at +) VALUES +(gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Tech Sponsorship'), + (SELECT id FROM users WHERE username = 'creator1'), (SELECT id FROM users WHERE username = 'brand1'), + 'https://contracts.example.com/tech-twitter-1.pdf', 'signed', 500.00, 15000, 3.2, 'post', + 'brand_awareness', 'twitter', 1, 'none', 5, 42.8, false, + '{"initial_price": 450, "final_price": 500, "negotiation_rounds": 1}'::jsonb, + '{"impressions": 20000, "clicks": 1000, "conversions": 50, "engagement_rate": 3.2}'::jsonb, + NOW() - INTERVAL '80 days'), + +(gen_random_uuid()::text, (SELECT id FROM sponsorships WHERE title = 'Fashion Sponsorship'), + (SELECT id FROM users WHERE username = 'creator2'), (SELECT id FROM users WHERE username = 'brand1'), + 'https://contracts.example.com/fashion-twitter-1.pdf', 'signed', 400.00, 8000, 2.9, 'post', + 'sales', 'twitter', 1, 'none', 4, 35.6, false, + '{"initial_price": 350, "final_price": 400, "negotiation_rounds": 1}'::jsonb, + '{"impressions": 15000, "clicks": 750, "conversions": 37, "engagement_rate": 2.9}'::jsonb, + NOW() - INTERVAL '95 days'); + +-- Add missing columns and tables for AI pricing optimization system + +-- 1. Add learning fields to contracts table +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS brand_satisfaction_score INTEGER; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS roi_achieved DECIMAL(5,2); +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS repeat_business BOOLEAN DEFAULT false; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS price_negotiation_history JSONB; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS campaign_success_metrics JSONB; + +-- 2. Add creator metrics for similarity matching +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS creator_followers INTEGER; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS creator_engagement_rate DECIMAL(5,4); +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS content_type VARCHAR(50); +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS campaign_type VARCHAR(50); +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS platform VARCHAR(50); +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS duration_weeks INTEGER; +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS exclusivity_level VARCHAR(50) DEFAULT 'none'; + +-- 3. Add market intelligence fields +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS market_trend_score DECIMAL(3,2); +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS seasonal_factor DECIMAL(3,2); +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS industry_benchmark_rate DECIMAL(5,2); +ALTER TABLE contracts ADD COLUMN IF NOT EXISTS competitor_pricing JSONB; + +-- 4. Create pricing feedback table +CREATE TABLE IF NOT EXISTS pricing_feedback ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + contract_id VARCHAR REFERENCES contracts(id) ON DELETE CASCADE, + recommended_price DECIMAL(10,2), + actual_price DECIMAL(10,2), + price_accuracy_score INTEGER, -- 1-10 scale + market_conditions TEXT, + feedback_notes TEXT, + created_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + +-- 5. Create pricing recommendations table +CREATE TABLE IF NOT EXISTS pricing_recommendations ( + id VARCHAR PRIMARY KEY DEFAULT gen_random_uuid()::text, + contract_id VARCHAR REFERENCES contracts(id) ON DELETE CASCADE, + recommended_price DECIMAL(10,2), + confidence_score DECIMAL(3,2), -- 0-1 scale + reasoning TEXT, -- AI explanation + similar_contracts_used JSONB, -- IDs of similar contracts + market_factors JSONB, -- Market conditions considered + created_at TIMESTAMP WITH TIME ZONE DEFAULT now() +); + diff --git a/Backend/test_roi_integration.py b/Backend/test_roi_integration.py new file mode 100644 index 0000000..04a18a0 --- /dev/null +++ b/Backend/test_roi_integration.py @@ -0,0 +1,328 @@ +""" +Integration tests for ROI Analytics API + +Tests the ROI service integration with FastAPI endpoints. +""" + +import pytest +from fastapi.testclient import TestClient +from sqlalchemy import create_engine +from sqlalchemy.orm import sessionmaker +from datetime import datetime, timedelta +from decimal import Decimal + +from app.main import app +from app.db.db import get_db, Base +from app.models.models import ( + User, Sponsorship, CampaignMetrics, SponsorshipPayment +) + + +# Test database setup +SQLALCHEMY_DATABASE_URL = "sqlite:///./test_roi.db" +engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}) +TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) + + +def override_get_db(): + try: + db = TestingSessionLocal() + yield db + finally: + db.close() + + +def override_get_current_user(): + """Override current user for testing""" + return User( + id="brand_123", + username="testbrand", + email="brand@test.com", + role="brand" + ) + + +app.dependency_overrides[get_db] = override_get_db + +# Import and override the get_current_user dependency +import app.routes.roi_analytics as roi_routes +app.dependency_overrides[roi_routes.get_current_user] = override_get_current_user + + +@pytest.fixture(scope="module") +def setup_database(): + """Set up test database with sample data""" + Base.metadata.create_all(bind=engine) + + db = TestingSessionLocal() + + # Create test user (brand) + brand_user = User( + id="brand_123", + username="testbrand", + email="brand@test.com", + role="brand" + ) + db.add(brand_user) + + # Create test campaign + campaign = Sponsorship( + id="campaign_123", + brand_id="brand_123", + title="Test Campaign", + description="Test campaign for ROI testing", + budget=Decimal('1000.00'), + status="active" + ) + db.add(campaign) + + # Create test metrics + metrics_1 = CampaignMetrics( + id="metrics_1", + campaign_id="campaign_123", + impressions=5000, + clicks=150, + conversions=10, + revenue=Decimal('500.00'), + reach=3000, + engagement_rate=Decimal('0.05'), + click_through_rate=Decimal('0.03'), + cost_per_acquisition=Decimal('50.00'), + return_on_investment=Decimal('0.25'), + recorded_at=datetime.now() - timedelta(days=5) + ) + db.add(metrics_1) + + metrics_2 = CampaignMetrics( + id="metrics_2", + campaign_id="campaign_123", + impressions=3000, + clicks=90, + conversions=5, + revenue=Decimal('300.00'), + reach=2000, + engagement_rate=Decimal('0.04'), + click_through_rate=Decimal('0.03'), + cost_per_acquisition=Decimal('60.00'), + return_on_investment=Decimal('0.20'), + recorded_at=datetime.now() - timedelta(days=2) + ) + db.add(metrics_2) + + # Create test payment + payment = SponsorshipPayment( + id="payment_123", + creator_id="creator_123", + brand_id="brand_123", + sponsorship_id="campaign_123", + amount=Decimal('1000.00'), + status="completed", + transaction_date=datetime.now() - timedelta(days=10) + ) + db.add(payment) + + db.commit() + db.close() + + yield + + # Cleanup + Base.metadata.drop_all(bind=engine) + + +@pytest.fixture +def client(): + """Test client for API requests""" + return TestClient(app) + + +class TestROIAnalyticsAPI: + """Test suite for ROI Analytics API endpoints""" + + def test_get_campaign_roi(self, client, setup_database): + """Test getting campaign ROI metrics""" + response = client.get("/api/roi/campaigns/campaign_123?days=30") + + assert response.status_code == 200 + data = response.json() + + assert data["campaign_id"] == "campaign_123" + assert "total_spend" in data + assert "total_revenue" in data + assert "roi_percentage" in data + assert "cost_per_acquisition" in data + assert "conversions" in data + assert "impressions" in data + assert "reach" in data + assert "engagement_rate" in data + assert "click_through_rate" in data + assert "period_start" in data + assert "period_end" in data + + # Verify calculated values + assert data["total_revenue"] == 800.0 # 500 + 300 + assert data["conversions"] == 15 # 10 + 5 + assert data["impressions"] == 8000 # 5000 + 3000 + assert data["reach"] == 5000 # 3000 + 2000 + + def test_get_campaign_roi_trends(self, client, setup_database): + """Test getting campaign ROI trends""" + response = client.get("/api/roi/campaigns/campaign_123/trends?period_type=daily&num_periods=7") + + assert response.status_code == 200 + data = response.json() + + assert isinstance(data, list) + # Should have some trend data + if data: # If there's data + trend = data[0] + assert "period" in trend + assert "roi_percentage" in trend + assert "spend" in trend + assert "revenue" in trend + assert "conversions" in trend + assert "date" in trend + + def test_compare_campaign_roi_to_targets(self, client, setup_database): + """Test comparing campaign ROI to targets""" + response = client.get( + "/api/roi/campaigns/campaign_123/targets?target_roi=15.0&target_cpa=55.0&days=30" + ) + + assert response.status_code == 200 + data = response.json() + + assert "target_roi" in data + assert "actual_roi" in data + assert "target_cpa" in data + assert "actual_cpa" in data + assert "target_met" in data + assert "variance_percentage" in data + + assert data["target_roi"] == 15.0 + assert data["target_cpa"] == 55.0 + assert isinstance(data["target_met"], bool) + + def test_get_campaigns_roi_summary(self, client, setup_database): + """Test getting ROI summary for multiple campaigns""" + response = client.get("/api/roi/campaigns/summary", params={ + "campaign_ids": ["campaign_123"], + "days": 30 + }) + + print(f"Response status: {response.status_code}") + print(f"Response content: {response.content}") + assert response.status_code == 200 + data = response.json() + + assert isinstance(data, dict) + assert "campaign_123" in data + + campaign_data = data["campaign_123"] + assert "campaign_id" in campaign_data + assert "total_spend" in campaign_data + assert "total_revenue" in campaign_data + assert "roi_percentage" in campaign_data + + def test_get_brand_portfolio_roi(self, client, setup_database): + """Test getting brand portfolio ROI""" + response = client.get("/api/roi/portfolio/brand_123?days=30&include_top_campaigns=5") + + assert response.status_code == 200 + data = response.json() + + assert "brand_id" in data + assert "portfolio_metrics" in data + assert "campaign_count" in data + assert "top_performing_campaigns" in data + + assert data["brand_id"] == "brand_123" + assert isinstance(data["campaign_count"], int) + assert isinstance(data["top_performing_campaigns"], list) + + portfolio_metrics = data["portfolio_metrics"] + assert "total_spend" in portfolio_metrics + assert "total_revenue" in portfolio_metrics + assert "roi_percentage" in portfolio_metrics + + def test_get_roi_benchmarks(self, client, setup_database): + """Test getting ROI benchmarks""" + response = client.get("/api/roi/benchmarks") + + assert response.status_code == 200 + data = response.json() + + assert "all_benchmarks" in data + benchmarks = data["all_benchmarks"] + + assert "general" in benchmarks + assert "by_industry" in benchmarks + assert "by_platform" in benchmarks + + general = benchmarks["general"] + assert "average_roi" in general + assert "good_roi" in general + assert "excellent_roi" in general + assert "average_cpa" in general + assert "average_ctr" in general + assert "average_engagement_rate" in general + + def test_get_roi_benchmarks_by_industry(self, client, setup_database): + """Test getting ROI benchmarks filtered by industry""" + response = client.get("/api/roi/benchmarks?industry=fashion") + + assert response.status_code == 200 + data = response.json() + + assert "industry" in data + assert "benchmarks" in data + assert "general_benchmarks" in data + + assert data["industry"] == "fashion" + benchmarks = data["benchmarks"] + assert "average_roi" in benchmarks + assert "average_cpa" in benchmarks + + def test_get_roi_benchmarks_by_platform(self, client, setup_database): + """Test getting ROI benchmarks filtered by platform""" + response = client.get("/api/roi/benchmarks?platform=instagram") + + assert response.status_code == 200 + data = response.json() + + assert "platform" in data + assert "benchmarks" in data + assert "general_benchmarks" in data + + assert data["platform"] == "instagram" + benchmarks = data["benchmarks"] + assert "average_roi" in benchmarks + assert "average_cpa" in benchmarks + + def test_campaign_not_found(self, client, setup_database): + """Test handling of non-existent campaign""" + response = client.get("/api/roi/campaigns/nonexistent_campaign") + + assert response.status_code == 404 + data = response.json() + assert "detail" in data + + def test_invalid_period_type(self, client, setup_database): + """Test handling of invalid period type in trends""" + response = client.get("/api/roi/campaigns/campaign_123/trends?period_type=invalid") + + assert response.status_code == 422 # Validation error + + def test_invalid_days_parameter(self, client, setup_database): + """Test handling of invalid days parameter""" + response = client.get("/api/roi/campaigns/campaign_123?days=0") + + assert response.status_code == 422 # Validation error + + response = client.get("/api/roi/campaigns/campaign_123?days=400") + + assert response.status_code == 422 # Validation error + + +if __name__ == "__main__": + pytest.main([__file__, "-v"]) \ No newline at end of file diff --git a/Backend/test_smart_contract_features.py b/Backend/test_smart_contract_features.py new file mode 100644 index 0000000..27c7199 --- /dev/null +++ b/Backend/test_smart_contract_features.py @@ -0,0 +1,155 @@ +import os +import requests +import json +from dotenv import load_dotenv + +# Load environment variables +load_dotenv() + +def test_smart_contract_features(): + """Test the new Smart Contract Generator features""" + + base_url = "http://localhost:8000" + + print("🧪 Testing Smart Contract Generator Features") + print("=" * 50) + + # Test 1: Check if the backend is running + try: + response = requests.get(f"{base_url}/docs") + if response.status_code == 200: + print("✅ Backend is running") + else: + print("❌ Backend is not responding") + return + except Exception as e: + print(f"❌ Cannot connect to backend: {e}") + return + + # Test 2: Test pricing recommendation with fallback + print("\n📊 Testing Pricing Recommendation with Fallback...") + try: + pricing_data = { + "creator_followers": 5000, + "creator_engagement_rate": 2.5, + "content_type": "youtube_shorts", + "campaign_type": "product_launch", + "platform": "youtube", + "duration_weeks": 2, # This is still used by pricing service + "exclusivity_level": "none" + } + + response = requests.post( + f"{base_url}/api/pricing/recommendation", + json=pricing_data, + headers={"Content-Type": "application/json"} + ) + + if response.status_code == 200: + data = response.json() + print(f"✅ Pricing recommendation received") + print(f" - Recommended price: ${data.get('recommended_price', 0):,.2f}") + print(f" - Confidence score: {data.get('confidence_score', 0):.1%}") + print(f" - Fallback used: {data.get('market_factors', {}).get('fallback_used', False)}") + if data.get('market_factors', {}).get('fallback_used'): + print(f" - Fallback reason: {data.get('market_factors', {}).get('reason', 'Unknown')}") + else: + print(f"❌ Pricing recommendation failed: {response.status_code}") + print(f" Response: {response.text}") + + except Exception as e: + print(f"❌ Pricing recommendation test failed: {e}") + + # Test 3: Test contract generation with new features + print("\n📝 Testing Contract Generation with New Features...") + try: + contract_data = { + "creator_id": "u113", + "brand_id": "u114", + "contract_type": "custom", + "custom_contract_type": "Brand Ambassador Partnership", + "min_budget": 1000, + "max_budget": 3000, + "content_type": ["youtube_shorts", "instagram_reel", "custom"], + "custom_content_types": ["TikTok Dance Challenge"], + "duration_value": 3, + "duration_unit": "months", + "requirements": "Create engaging content for our new product launch", + "industry": "Fashion", + "exclusivity": "platform", + "compliance_requirements": ["FTC Disclosure Required"], + "jurisdiction": "california", + "dispute_resolution": "arbitration" + } + + response = requests.post( + f"{base_url}/api/contracts/generation/generate", + json=contract_data, + headers={"Content-Type": "application/json"} + ) + + if response.status_code == 200: + data = response.json() + print(f"✅ Contract generation successful") + print(f" - Contract title: {data.get('contract_title', 'N/A')}") + print(f" - Contract type: {data.get('contract_type', 'N/A')}") + print(f" - Custom contract type: {data.get('custom_contract_type', 'N/A')}") + print(f" - Duration: {data.get('duration_value', 0)} {data.get('duration_unit', 'weeks')}") + print(f" - Content types: {', '.join(data.get('content_types', []))}") + print(f" - Custom content types: {', '.join(data.get('custom_content_types', []))}") + print(f" - Total budget: ${data.get('total_budget', 0):,.2f}") + print(f" - Risk score: {data.get('risk_score', 0):.1%}") + else: + print(f"❌ Contract generation failed: {response.status_code}") + print(f" Response: {response.text}") + + except Exception as e: + print(f"❌ Contract generation test failed: {e}") + + # Test 4: Test content type multipliers + print("\n🎯 Testing Content Type Multipliers...") + content_types = [ + "youtube_shorts", "youtube_video", "youtube_live", + "instagram_post", "instagram_reel", "instagram_story", "instagram_live", + "tiktok_video", "tiktok_live", + "facebook_post", "facebook_live", + "twitter_post", "twitter_space", + "linkedin_post", "linkedin_article", + "blog_post", "podcast", "newsletter" + ] + + print(f" Supported content types: {len(content_types)}") + for content_type in content_types[:5]: # Show first 5 + print(f" - {content_type}") + print(f" ... and {len(content_types) - 5} more") + + # Test 5: Test duration unit conversion + print("\n⏰ Testing Duration Unit Conversion...") + test_cases = [ + (7, "days"), + (4, "weeks"), + (3, "months"), + (1, "years") + ] + + for value, unit in test_cases: + weeks = { + "days": value / 7, + "weeks": value, + "months": value * 4.33, + "years": value * 52 + }.get(unit, value) + print(f" {value} {unit} = {weeks:.1f} weeks") + + print("\n🎉 Smart Contract Generator Feature Tests Complete!") + print("\n📋 Summary of New Features:") + print(" ✅ Custom contract types with 'Other' option") + print(" ✅ Enhanced content types (YouTube Shorts, Instagram Reels, etc.)") + print(" ✅ Duration unit toggle (days, weeks, months, years)") + print(" ✅ Pricing fallback message when insufficient data") + print(" ✅ Database columns added for all new features") + print(" ✅ Backend API updated to handle new fields") + print(" ✅ Frontend interface updated with new options") + +if __name__ == "__main__": + test_smart_contract_features() diff --git a/Backend/updated_contract.txt b/Backend/updated_contract.txt new file mode 100644 index 0000000..70748ba --- /dev/null +++ b/Backend/updated_contract.txt @@ -0,0 +1,106 @@ +================================================================================ + CONTRACT DOCUMENT +================================================================================ + +📋 CONTRACT OVERVIEW +---------------------------------------- +Contract Title: Updated Test Contrayuyuy +Contract Type: one-time +Status: draft +Created: 2025-08-02T01:36:43.716801+00:00 +Last Updated: 2025-08-06T00:11:06.910057+00:00 + +👥 PARTIES INVOLVED +---------------------------------------- +Brand ID: u111 +Creator ID: u116 + +📅 TIMELINE +---------------------------------------- +Start Date: 2025-08-06 +End Date: 2025-08-14 + +💰 FINANCIAL DETAILS +---------------------------------------- +Total Budget: $3,000.00 + +Payment Terms: + • Currency: EUR + • Late Fees: Updated late fees + • Final Payment: 60% on completion + • Payment Method: Bank transfer + • Advance Payment: 40% advance + • Payment Schedule: Updated payment schedule + +📦 DELIVERABLES +---------------------------------------- +Format: 1080p HD +Quantity: 5 posts and 2 videos +Timeline: 3 weeks +Content Type: Instagram posts and YouTube videos +Specifications: Detailed specifications for all deliverables +Revision Policy: 2 rounds of revisions included + +📜 TERMS AND CONDITIONS +---------------------------------------- +Exclusivity: Non-exclusive agreement +Jurisdiction: mumbai +Usage Rights: Full usage rights granted. +Additional Terms: Additional terms here +Brand Guidelines: Updated brand guidelines +Content Guidelines: Updated content guidelines +Dispute Resolution: mediation +Disclosure Requirements: Updated FTC compliance + +⚖️ LEGAL COMPLIANCE +---------------------------------------- +Ftc Compliance: True +Disclosure Required: True + +💬 NEGOTIATION HISTORY +---------------------------------------- + +Message 1: +From: test_user +Time: January 01, 2024 at 12:00 AM +Message: Test comment from updated backend +------------------------------ + +Message 2: +From: test_user +Time: January 01, 2024 at 12:00 AM +Message: Another test comment with dedicated columns +------------------------------ + +Message 3: +From: test_user +Time: January 01, 2024 at 12:00 AM +Message: Test comment for frontend visibility +------------------------------ + +📝 UPDATE HISTORY +---------------------------------------- + +Update 1: +Updated by: test_user +Time: January 01, 2024 at 12:00 AM + • Comments: Test comment from updated backend +------------------------------ + +Update 2: +Updated by: test_user +Time: January 01, 2024 at 12:00 AM + • Comments: Another test comment with dedicated columns +------------------------------ + +Update 3: +Updated by: test_user +Time: January 01, 2024 at 12:00 AM + • Comments: Test comment for frontend visibility +------------------------------ + +================================================================================ + END OF CONTRACT DOCUMENT +================================================================================ +Generated on: August 07, 2025 at 03:44 AM +Document ID: 6f780c78-3ec5-4102-a22b-784174a57f35 diff --git a/Frontend/README-INTEGRATION.md b/Frontend/README-INTEGRATION.md new file mode 100644 index 0000000..251b6bd --- /dev/null +++ b/Frontend/README-INTEGRATION.md @@ -0,0 +1,60 @@ +# Frontend-Backend Integration + +## 🚀 Connected Successfully! + +Your brand dashboard frontend is now fully connected to the backend API. + +## 📋 What's Integrated: + +### **API Service (`brandApi.ts`)** +- Complete API client for all brand dashboard endpoints +- Type-safe TypeScript interfaces +- Error handling and response parsing +- All CRUD operations for campaigns, profiles, applications, payments + +### **Custom Hook (`useBrandDashboard.ts`)** +- State management for all dashboard data +- Loading states and error handling +- Real-time data synchronization +- AI query integration + +### **Enhanced Dashboard Component** +- Real-time data display +- AI-powered search functionality +- Loading and error states +- Interactive metrics dashboard + +## 🔗 API Endpoints Connected: + +- ✅ Dashboard Overview +- ✅ Brand Profile Management +- ✅ Campaign CRUD Operations +- ✅ Creator Matching & Search +- ✅ Application Management +- ✅ Payment Tracking +- ✅ Analytics & Performance +- ✅ AI-Powered Natural Language Search + +## 🎯 Features Working: + +1. **Real-time Dashboard Metrics** +2. **AI Search Bar** - Ask questions in natural language +3. **Campaign Management** +4. **Creator Discovery** +5. **Application Tracking** +6. **Payment Analytics** + +## 🚀 How to Test: + +1. **Start Backend:** `cd Backend && python -m uvicorn app.main:app --reload` +2. **Start Frontend:** `cd Frontend && npm run dev` +3. **Navigate to:** `http://localhost:5173/brand/dashboard` +4. **Try AI Search:** Type questions like "Show me my campaigns" or "Find creators for tech industry" + +## 🔧 Configuration: + +- Backend runs on: `http://localhost:8000` +- Frontend runs on: `http://localhost:5173` +- API proxy configured in `vite.config.ts` + +Your brand dashboard is now fully functional! 🎉 \ No newline at end of file diff --git a/Frontend/public/aossielogo.png b/Frontend/public/aossielogo.png new file mode 100644 index 0000000..b2421da Binary files /dev/null and b/Frontend/public/aossielogo.png differ diff --git a/Frontend/public/facebook.png b/Frontend/public/facebook.png index 0c37594..75796ac 100644 Binary files a/Frontend/public/facebook.png and b/Frontend/public/facebook.png differ diff --git a/Frontend/public/instagram.png b/Frontend/public/instagram.png index 82216ba..6181afa 100644 Binary files a/Frontend/public/instagram.png and b/Frontend/public/instagram.png differ diff --git a/Frontend/public/linkedin.png b/Frontend/public/linkedin.png new file mode 100644 index 0000000..4fcaa76 Binary files /dev/null and b/Frontend/public/linkedin.png differ diff --git a/Frontend/public/twitter.png b/Frontend/public/twitter.png new file mode 100644 index 0000000..21ba26e Binary files /dev/null and b/Frontend/public/twitter.png differ diff --git a/Frontend/public/youtube.png b/Frontend/public/youtube.png index 2db89d2..5abdb7b 100644 Binary files a/Frontend/public/youtube.png and b/Frontend/public/youtube.png differ diff --git a/Frontend/src/App.tsx b/Frontend/src/App.tsx index 60f7ecd..3fba86d 100644 --- a/Frontend/src/App.tsx +++ b/Frontend/src/App.tsx @@ -18,8 +18,10 @@ import { AuthProvider } from "./context/AuthContext"; import ProtectedRoute from "./components/ProtectedRoute"; import PublicRoute from "./components/PublicRoute"; import Dashboard from "./pages/Brand/Dashboard"; +import DashboardOverview from "./pages/Brand/DashboardOverview"; import BasicDetails from "./pages/BasicDetails"; import Onboarding from "./components/Onboarding"; +import ErrorBoundary from "./components/ErrorBoundary"; function App() { const [isLoading, setIsLoading] = useState(true); @@ -68,6 +70,18 @@ function App() { } /> + + + + } /> + + + + + + } /> } /> } /> { + constructor(props: Props) { + super(props); + this.state = { hasError: false }; + } + + static getDerivedStateFromError(error: Error): State { + return { hasError: true, error }; + } + + componentDidCatch(error: Error, errorInfo: ErrorInfo) { + console.error('Error caught by boundary:', error, errorInfo); + } + + render() { + if (this.state.hasError) { + return ( +
+
+
+
+ ⚠️ +
+

Something went wrong

+

+ We encountered an error while loading the page. Please try refreshing. +

+
+

+ {this.state.error?.message || 'Unknown error'} +

+
+ +
+
+
+ ); + } + + return this.props.children; + } +} + +export default ErrorBoundary; \ No newline at end of file diff --git a/Frontend/src/components/analytics/metrics-chart.tsx b/Frontend/src/components/analytics/metrics-chart.tsx new file mode 100644 index 0000000..965e859 --- /dev/null +++ b/Frontend/src/components/analytics/metrics-chart.tsx @@ -0,0 +1,250 @@ +import React from 'react'; +import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'; +import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer, BarChart, Bar, PieChart, Pie, Cell } from 'recharts'; +import ErrorState from '@/components/ui/error-state'; +import EmptyState from '@/components/ui/empty-state'; + +interface ChartDataPoint { + date: string; + reach: number; + impressions: number; + engagementRate: number; + likes: number; + comments: number; + shares: number; +} + +interface MetricsChartProps { + data: ChartDataPoint[]; + chartType?: 'line' | 'bar' | 'pie'; + metric?: 'reach' | 'impressions' | 'engagementRate' | 'likes' | 'comments' | 'shares'; + title?: string; + description?: string; + loading?: boolean; + error?: { + type?: 'network' | 'api' | 'auth' | 'permission' | 'not-found' | 'rate-limit' | 'generic'; + message?: string; + }; + onRetry?: () => void; + onConnectAccounts?: () => void; + retryLoading?: boolean; +} + +const MetricsChart: React.FC = ({ + data, + chartType = 'line', + metric = 'reach', + title = 'Performance Metrics', + description = 'Track your content performance over time', + loading = false, + error, + onRetry, + onConnectAccounts, + retryLoading = false +}) => { + const colors = { + reach: '#6366f1', + impressions: '#8b5cf6', + engagementRate: '#ec4899', + likes: '#f59e0b', + comments: '#3b82f6', + shares: '#06b6d4' + }; + + const formatValue = (value: number, metricType: string) => { + if (metricType === 'engagementRate') { + return `${value.toFixed(1)}%`; + } + if (value >= 1000000) { + return `${(value / 1000000).toFixed(1)}M`; + } + if (value >= 1000) { + return `${(value / 1000).toFixed(1)}K`; + } + return value.toString(); + }; + + const CustomTooltip = ({ active, payload, label }: any) => { + if (active && payload && payload.length) { + return ( +
+

{label}

+ {payload.map((entry: any, index: number) => ( +

+ {`${entry.name}: ${formatValue(entry.value, entry.dataKey)}`} +

+ ))} +
+ ); + } + return null; + }; + + const renderLineChart = () => ( + + + + new Date(value).toLocaleDateString('en-US', { month: 'short', day: 'numeric' })} + /> + formatValue(value, metric)} + /> + } /> + + + + ); + + const renderBarChart = () => ( + + + + new Date(value).toLocaleDateString('en-US', { month: 'short', day: 'numeric' })} + /> + formatValue(value, metric)} + /> + } /> + + + + ); + + const renderPieChart = () => { + const pieData = [ + { name: 'Likes', value: data.reduce((sum, d) => sum + d.likes, 0), color: colors.likes }, + { name: 'Comments', value: data.reduce((sum, d) => sum + d.comments, 0), color: colors.comments }, + { name: 'Shares', value: data.reduce((sum, d) => sum + d.shares, 0), color: colors.shares } + ]; + + return ( + + + `${name} ${(percent * 100).toFixed(0)}%`} + outerRadius={80} + fill="#8884d8" + dataKey="value" + > + {pieData.map((entry, index) => ( + + ))} + + formatValue(Number(value), 'number')} /> + + + ); + }; + + const renderChart = () => { + switch (chartType) { + case 'bar': + return renderBarChart(); + case 'pie': + return renderPieChart(); + default: + return renderLineChart(); + } + }; + + // Error state + if (error) { + return ( + + + {title} + {description} + + + + + + ); + } + + // Loading state + if (loading) { + return ( + + + {title} + {description} + + +
+
+
+ + + ); + } + + // Empty state + if (!data || data.length === 0) { + return ( + + + {title} + {description} + + + + + + ); + } + + return ( + + + {title} + {description} + + + {renderChart()} + + + ); +}; + +export default MetricsChart; \ No newline at end of file diff --git a/Frontend/src/components/chat/BrandChatAssistant.tsx b/Frontend/src/components/chat/BrandChatAssistant.tsx new file mode 100644 index 0000000..ef3413e --- /dev/null +++ b/Frontend/src/components/chat/BrandChatAssistant.tsx @@ -0,0 +1,316 @@ +import React, { useState, useRef, useEffect } from "react"; + +// Message type for chat +export type ChatMessage = { + sender: "user" | "ai"; + text: string; + result?: any; // For future result rendering + error?: string; +}; + +interface BrandChatAssistantProps { + initialQuery: string; + onClose: () => void; + sessionId: string | null; + setSessionId: (sessionId: string | null) => void; +} + +const BrandChatAssistant: React.FC = ({ + initialQuery, + onClose, + sessionId, + setSessionId +}) => { + const [messages, setMessages] = useState([ + { sender: "user", text: initialQuery }, + ]); + const [input, setInput] = useState(""); + const [loading, setLoading] = useState(false); + const chatEndRef = useRef(null); + + // Scroll to bottom on new message + useEffect(() => { + chatEndRef.current?.scrollIntoView({ behavior: "smooth" }); + }, [messages]); + + // Send message to backend API + const sendMessageToBackend = async (message: string, currentSessionId?: string) => { + try { + const response = await fetch('/api/ai/query', { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + ...(currentSessionId && { 'X-Session-ID': currentSessionId }), + }, + body: JSON.stringify({ + query: message, + brand_id: "550e8400-e29b-41d4-a716-446655440000", // Test brand ID - TODO: Get from auth context + context: currentSessionId ? { session_id: currentSessionId } : undefined, + }), + }); + + if (!response.ok) { + throw new Error(`HTTP error! status: ${response.status}`); + } + + const data = await response.json(); + + // Update session ID if provided + if (data.session_id && !currentSessionId) { + setSessionId(data.session_id); + } + + return data; + } catch (error) { + console.error('Error calling AI API:', error); + throw error; + } + }; + + // Handle initial AI response + useEffect(() => { + if (messages.length === 1) { + setLoading(true); + sendMessageToBackend(initialQuery) + .then((response) => { + const aiMessage: ChatMessage = { + sender: "ai", + text: response.explanation || "I understand your request. Let me help you with that.", + result: response.result, + }; + setMessages((msgs) => [...msgs, aiMessage]); + }) + .catch((error) => { + const errorMessage: ChatMessage = { + sender: "ai", + text: "Sorry, I encountered an error processing your request. Please try again.", + error: error.message, + }; + setMessages((msgs) => [...msgs, errorMessage]); + }) + .finally(() => { + setLoading(false); + }); + } + }, []); + + const sendMessage = async () => { + if (!input.trim()) return; + + const userMsg: ChatMessage = { sender: "user", text: input }; + setMessages((msgs) => [...msgs, userMsg]); + setInput(""); + setLoading(true); + + try { + const response = await sendMessageToBackend(input, sessionId || undefined); + + const aiMessage: ChatMessage = { + sender: "ai", + text: response.explanation || "I've processed your request.", + result: response.result, + }; + + setMessages((msgs) => [...msgs, aiMessage]); + } catch (error) { + const errorMessage: ChatMessage = { + sender: "ai", + text: "Sorry, I encountered an error. Please try again.", + error: error instanceof Error ? error.message : "Unknown error", + }; + setMessages((msgs) => [...msgs, errorMessage]); + } finally { + setLoading(false); + } + }; + + return ( +
+ {/* Header */} +
+ + 🤖 Brand AI Assistant + + +
+ + {/* Chat history */} +
+ {messages.map((msg, idx) => ( +
+
+ {msg.text} + {msg.result && ( +
+ Result: {JSON.stringify(msg.result, null, 2)} +
+ )} +
+
+ ))} + {loading && ( +
+
+ AI is typing… +
+ )} +
+
+ + {/* Input */} +
+ setInput(e.target.value)} + onKeyDown={(e) => e.key === "Enter" && sendMessage()} + placeholder="Type your message…" + style={{ + flex: 1, + padding: 12, + borderRadius: 10, + border: "1px solid #333", + background: "#222", + color: "#fff", + fontSize: 15, + outline: "none", + }} + disabled={loading} + /> + +
+ + {/* CSS for loading animation */} + +
+ ); +}; + +export default BrandChatAssistant; \ No newline at end of file diff --git a/Frontend/src/components/collaboration-hub/CreatorMatchGrid.tsx b/Frontend/src/components/collaboration-hub/CreatorMatchGrid.tsx index 57c1f01..db435e7 100644 --- a/Frontend/src/components/collaboration-hub/CreatorMatchGrid.tsx +++ b/Frontend/src/components/collaboration-hub/CreatorMatchGrid.tsx @@ -18,8 +18,8 @@ const CreatorMatchGrid: React.FC = ({ creators }) => { return (
- {currentCreators.map((creator) => ( - + {currentCreators.map((creator, index) => ( + ))}
diff --git a/Frontend/src/components/contracts/AdvancedFilters.tsx b/Frontend/src/components/contracts/AdvancedFilters.tsx new file mode 100644 index 0000000..80a9155 --- /dev/null +++ b/Frontend/src/components/contracts/AdvancedFilters.tsx @@ -0,0 +1,405 @@ +import React, { useState } from 'react'; +import { Filter, X, Calendar, DollarSign, Type, User, Building } from 'lucide-react'; + +interface FilterOptions { + status: string; + contract_type: string; + min_budget: string; + max_budget: string; + start_date_from: string; + start_date_to: string; + creator_id: string; + brand_id: string; + search_term: string; +} + +interface AdvancedFiltersProps { + filters: FilterOptions; + onFiltersChange: (filters: FilterOptions) => void; + onClearFilters: () => void; + isOpen: boolean; + onToggle: () => void; +} + +const AdvancedFilters: React.FC = ({ + filters, + onFiltersChange, + onClearFilters, + isOpen, + onToggle +}) => { + const handleFilterChange = (key: keyof FilterOptions, value: string) => { + onFiltersChange({ + ...filters, + [key]: value + }); + }; + + const handleClearFilters = () => { + onClearFilters(); + }; + + const hasActiveFilters = Object.values(filters).some(value => value !== '' && value !== 'all'); + + return ( +
+ {/* Header */} +
+
+ + Advanced Filters + {hasActiveFilters && ( +
+ Active +
+ )} +
+
+ {hasActiveFilters && ( + + )} +
+
+ + {/* Filters Content */} + {isOpen && ( +
+
+ {/* Status Filter */} +
+ + +
+ + {/* Contract Type Filter */} +
+ + +
+ + {/* Budget Range */} +
+ +
+ handleFilterChange('min_budget', e.target.value)} + style={{ + flex: 1, + padding: '12px', + background: 'rgba(42, 42, 42, 0.6)', + border: '1px solid rgba(42, 42, 42, 0.8)', + borderRadius: '8px', + color: '#fff', + fontSize: '14px' + }} + /> + handleFilterChange('max_budget', e.target.value)} + style={{ + flex: 1, + padding: '12px', + background: 'rgba(42, 42, 42, 0.6)', + border: '1px solid rgba(42, 42, 42, 0.8)', + borderRadius: '8px', + color: '#fff', + fontSize: '14px' + }} + /> +
+
+ + {/* Date Range */} +
+ +
+ handleFilterChange('start_date_from', e.target.value)} + style={{ + flex: 1, + padding: '12px', + background: 'rgba(42, 42, 42, 0.6)', + border: '1px solid rgba(42, 42, 42, 0.8)', + borderRadius: '8px', + color: '#fff', + fontSize: '14px' + }} + /> + handleFilterChange('start_date_to', e.target.value)} + style={{ + flex: 1, + padding: '12px', + background: 'rgba(42, 42, 42, 0.6)', + border: '1px solid rgba(42, 42, 42, 0.8)', + borderRadius: '8px', + color: '#fff', + fontSize: '14px' + }} + /> +
+
+ + {/* Creator ID */} +
+ + handleFilterChange('creator_id', e.target.value)} + style={{ + width: '100%', + padding: '12px', + background: 'rgba(42, 42, 42, 0.6)', + border: '1px solid rgba(42, 42, 42, 0.8)', + borderRadius: '8px', + color: '#fff', + fontSize: '14px' + }} + /> +
+ + {/* Brand ID */} +
+ + handleFilterChange('brand_id', e.target.value)} + style={{ + width: '100%', + padding: '12px', + background: 'rgba(42, 42, 42, 0.6)', + border: '1px solid rgba(42, 42, 42, 0.8)', + borderRadius: '8px', + color: '#fff', + fontSize: '14px' + }} + /> +
+ + {/* Search Term */} +
+ + handleFilterChange('search_term', e.target.value)} + style={{ + width: '100%', + padding: '12px', + background: 'rgba(42, 42, 42, 0.6)', + border: '1px solid rgba(42, 42, 42, 0.8)', + borderRadius: '8px', + color: '#fff', + fontSize: '14px' + }} + /> +
+
+ + {/* Active Filters Summary */} + {hasActiveFilters && ( +
+
+ Active Filters: +
+
+ {filters.status !== 'all' && ( + + Status: {filters.status} + + )} + {filters.contract_type !== 'all' && ( + + Type: {filters.contract_type} + + )} + {(filters.min_budget || filters.max_budget) && ( + + Budget: ${filters.min_budget || '0'} - ${filters.max_budget || '∞'} + + )} + {(filters.start_date_from || filters.start_date_to) && ( + + Date: {filters.start_date_from || 'Any'} to {filters.start_date_to || 'Any'} + + )} + {filters.creator_id && ( + + Creator: {filters.creator_id} + + )} + {filters.brand_id && ( + + Brand: {filters.brand_id} + + )} + {filters.search_term && ( + + Search: "{filters.search_term}" + + )} +
+
+ )} +
+ )} +
+ ); +}; + +export default AdvancedFilters; \ No newline at end of file diff --git a/Frontend/src/components/contracts/ContractAIAssistant.tsx b/Frontend/src/components/contracts/ContractAIAssistant.tsx new file mode 100644 index 0000000..fa67dbb --- /dev/null +++ b/Frontend/src/components/contracts/ContractAIAssistant.tsx @@ -0,0 +1,346 @@ +import React, { useState, useRef, useEffect } from 'react'; +import { Send, Bot, User, Loader2, TrendingUp, AlertTriangle, CheckCircle } from 'lucide-react'; + +interface Message { + id: string; + type: 'user' | 'ai'; + content: string; + timestamp: Date; + analysis?: any; + suggestions?: string[]; +} + +interface ContractAIAssistantProps { + isOpen: boolean; + onClose: () => void; + selectedContractId?: string; +} + +const ContractAIAssistant: React.FC = ({ + isOpen, + onClose, + selectedContractId +}) => { + const [messages, setMessages] = useState([ + { + id: '1', + type: 'ai', + content: "Hello! I'm your AI Contract Assistant. I can help you analyze contracts, provide insights, and answer questions about your contract portfolio. What would you like to know?", + timestamp: new Date() + } + ]); + const [inputValue, setInputValue] = useState(''); + const [isLoading, setIsLoading] = useState(false); + const messagesEndRef = useRef(null); + + const scrollToBottom = () => { + messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' }); + }; + + useEffect(() => { + scrollToBottom(); + }, [messages]); + + const handleSendMessage = async () => { + if (!inputValue.trim() || isLoading) return; + + const userMessage: Message = { + id: Date.now().toString(), + type: 'user', + content: inputValue, + timestamp: new Date() + }; + + setMessages(prev => [...prev, userMessage]); + setInputValue(''); + setIsLoading(true); + + try { + const response = await fetch('http://localhost:8000/api/contracts/ai/chat', { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify({ + query: inputValue, + contract_id: selectedContractId + }), + }); + + if (!response.ok) { + throw new Error('Failed to get AI response'); + } + + const data = await response.json(); + + const aiMessage: Message = { + id: (Date.now() + 1).toString(), + type: 'ai', + content: data.response, + timestamp: new Date(), + analysis: data.analysis, + suggestions: data.suggestions + }; + + setMessages(prev => [...prev, aiMessage]); + } catch (error) { + console.error('Error sending message:', error); + const errorMessage: Message = { + id: (Date.now() + 1).toString(), + type: 'ai', + content: "I'm sorry, I encountered an error while processing your request. Please try again.", + timestamp: new Date() + }; + setMessages(prev => [...prev, errorMessage]); + } finally { + setIsLoading(false); + } + }; + + const handleKeyPress = (e: React.KeyboardEvent) => { + if (e.key === 'Enter' && !e.shiftKey) { + e.preventDefault(); + handleSendMessage(); + } + }; + + const renderAnalysis = (analysis: any) => { + if (!analysis) return null; + + return ( +
+

Contract Analysis

+ + {/* Risk Score */} +
+
+ Risk Score + + {(analysis.risk_score * 100).toFixed(0)}% + +
+
+
+
+
+ + {/* Risk Factors */} + {analysis.risk_factors && analysis.risk_factors.length > 0 && ( +
+ Risk Factors +
+ {analysis.risk_factors.map((factor: string, index: number) => ( + + {factor} + + ))} +
+
+ )} + + {/* Recommendations */} + {analysis.recommendations && analysis.recommendations.length > 0 && ( +
+ Recommendations +
+ {analysis.recommendations.map((rec: string, index: number) => ( +
+ + {rec} +
+ ))} +
+
+ )} + + {/* Performance Prediction */} +
+ Performance Prediction + + {analysis.performance_prediction} + +
+ + {/* Market Comparison */} + {analysis.market_comparison && ( +
+ Market Comparison +
+
+ Similar Contracts: + {analysis.market_comparison.similar_contracts_count} +
+
+ Budget Percentile: + + {analysis.market_comparison.budget_percentile.replace('_', ' ')} + +
+
+
+ )} +
+ ); + }; + + const renderSuggestions = (suggestions: string[]) => { + if (!suggestions || suggestions.length === 0) return null; + + return ( +
+ Quick Actions +
+ {suggestions.map((suggestion, index) => ( + + ))} +
+
+ ); + }; + + if (!isOpen) return null; + + return ( +
+
+ {/* Header */} +
+
+
+ +
+
+

AI Contract Assistant

+

+ {selectedContractId ? `Analyzing Contract: ${selectedContractId}` : 'General Contract Analysis'} +

+
+
+ +
+ + {/* Messages */} +
+ {messages.map((message) => ( +
+ {message.type === 'ai' && ( +
+ +
+ )} + +
+

{message.content}

+ + {message.type === 'ai' && message.analysis && renderAnalysis(message.analysis)} + {message.type === 'ai' && message.suggestions && renderSuggestions(message.suggestions)} + + + {message.timestamp.toLocaleTimeString()} + +
+ + {message.type === 'user' && ( +
+ +
+ )} +
+ ))} + + {isLoading && ( +
+
+ +
+
+
+ + AI is thinking... +
+
+
+ )} + +
+
+ + {/* Input */} +
+
+
+