Feat: Added Creator to brand and brand to creator matching...plus added some functional elements to the logged user homepage and made google auth functional in Signup/Login.

Backend/.env-example

@@ -5,4 +5,6 @@ port=5432
 dbname=postgres
 GROQ_API_KEY=
 SUPABASE_URL=
-SUPABASE_KEY=
+SUPABASE_KEY=
+GEMINI_API_KEY=
+YOUTUBE_API_KEY=

Backend/app/db/seed.py

@@ -1,6 +1,6 @@
-from datetime import datetime, timezone
-from db.db import AsyncSessionLocal
-from models.models import User
+from datetime import datetime
+from app.db.db import AsyncSessionLocal
+from app.models.models import User
 
 
 async def seed_db():
@@ -12,6 +12,8 @@ async def seed_db():
             "password": "password123",
             "role": "creator",
             "bio": "Lifestyle and travel content creator",
+            "profile_image": None,
+            "created_at": datetime.utcnow()
         },
         {
             "id": "6dbfcdd5-795f-49c1-8f7a-a5538b8c6f6f",
@@ -20,6 +22,8 @@ async def seed_db():
             "password": "password123",
             "role": "brand",
             "bio": "Sustainable fashion brand looking for influencers",
+            "profile_image": None,
+            "created_at": datetime.utcnow()
         },
     ]
 
@@ -40,11 +44,10 @@ async def seed_db():
                     id=user_data["id"],
                     username=user_data["username"],
                     email=user_data["email"],
-                    password_hash=user_data[
-                        "password"
-                    ],  # Using plain password directly
                     role=user_data["role"],
+                    profile_image=user_data["profile_image"],
                     bio=user_data["bio"],
+                    created_at=user_data["created_at"]
                 )
                 session.add(user)
                 print(f"Created user: {user_data['email']}")

Backend/app/main.py

@@ -1,15 +1,17 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from db.db import engine
-from db.seed import seed_db
-from models import models, chat
-from routes.post import router as post_router
-from routes.chat import router as chat_router
+from .db.db import engine
+from .db.seed import seed_db
+from .models import models, chat
+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 sqlalchemy.exc import SQLAlchemyError
 import logging
 import os
 from dotenv import load_dotenv
 from contextlib import asynccontextmanager
+from app.routes import ai
 
 # Load environment variables
 load_dotenv()
@@ -51,6 +53,9 @@ async def lifespan(app: FastAPI):
 # Include the routes
 app.include_router(post_router)
 app.include_router(chat_router)
+app.include_router(match_router)
+app.include_router(ai.router)
+app.include_router(ai.youtube_router)
 
 
 @app.get("/")

Backend/app/models/chat.py

@@ -1,7 +1,7 @@
 from sqlalchemy import Column, String, ForeignKey, DateTime, Enum, UniqueConstraint
 from sqlalchemy.orm import relationship
 from datetime import datetime, timezone
-from db.db import Base
+from app.db.db import Base
 import uuid
 import enum
 

Backend/app/models/models.py

@@ -9,10 +9,11 @@
     DECIMAL,
     DateTime,
     Boolean,
+    TIMESTAMP,
 )
 from sqlalchemy.orm import relationship
-from datetime import datetime, timezone
-from db.db import Base
+from datetime import datetime
+from app.db.db import Base
 import uuid
 
 
@@ -27,18 +28,14 @@ class User(Base):
     id = Column(String, primary_key=True, default=generate_uuid)
     username = Column(String, unique=True, nullable=False)
     email = Column(String, unique=True, nullable=False)
-    password_hash = Column(Text, nullable=False)  # Restored for now
+    # password_hash = Column(Text, nullable=False)  # Removed as Supabase handles auth
     role = Column(String, nullable=False)  # 'creator' or 'brand'
     profile_image = Column(Text, nullable=True)
     bio = Column(Text, nullable=True)
-    created_at = Column(
-        DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)
-    )
+    created_at = Column(TIMESTAMP, default=datetime.utcnow)
 
     is_online = Column(Boolean, default=False)  # ✅ Track if user is online
-    last_seen = Column(
-        DateTime(timezone=True), default=lambda: datetime.now(timezone.utc)
-    )
+    last_seen = Column(TIMESTAMP, default=datetime.utcnow)
 
     audience = relationship("AudienceInsights", back_populates="user", uselist=False)
     sponsorships = relationship("Sponsorship", back_populates="brand")

Backend/app/routes/ai.py

@@ -0,0 +1,101 @@
+# FastAPI router for AI-powered endpoints, including trending niches
+from fastapi import APIRouter, HTTPException, Query
+from datetime import date
+import os
+import requests
+import json
+from supabase import create_client, Client
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+# Initialize router
+router = APIRouter()
+
+# Load environment variables for Supabase and Gemini
+SUPABASE_URL = os.environ.get("SUPABASE_URL")
+SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+
+# Validate required environment variables
+if not all([SUPABASE_URL, SUPABASE_KEY, GEMINI_API_KEY]):
+    raise ValueError("Missing required environment variables: SUPABASE_URL, SUPABASE_KEY, GEMINI_API_KEY")
+
+supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+def fetch_from_gemini():
+    prompt = (
+        "List the top 6 trending content niches for creators and brands this week. For each, provide: name (the niche), insight (a short qualitative reason why it's trending), and global_activity (a number from 1 to 5, where 5 means very high global activity in this category, and 1 means low).Return as a JSON array of objects with keys: name, insight, global_activity."
+    )
+    url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-lite:generateContent?key={GEMINI_API_KEY}"
+    # Set up retry strategy
+    retry_strategy = Retry(
+        total=3,
+        backoff_factor=1,
+        status_forcelist=[429, 500, 502, 503, 504],
+        allowed_methods=["POST"],
+    )
+    adapter = HTTPAdapter(max_retries=retry_strategy)
+    http = requests.Session()
+    http.mount("https://", adapter)
+    http.mount("http://", adapter)
+    resp = http.post(url, json={"contents": [{"parts": [{"text": prompt}]}]}, timeout=(3.05, 10))
+    resp.raise_for_status()
+    print("Gemini raw response:", resp.text)
+    data = resp.json()
+    print("Gemini parsed JSON:", data)
+    text = data['candidates'][0]['content']['parts'][0]['text']
+    print("Gemini text to parse as JSON:", text)
+    # Remove Markdown code block if present
+    if text.strip().startswith('```'):
+        text = text.strip().split('\n', 1)[1]  # Remove the first line (```json)
+        text = text.rsplit('```', 1)[0]        # Remove the last ```
+        text = text.strip()
+    return json.loads(text)
+
+@router.get("/api/trending-niches")
+def trending_niches():
+    """
+    API endpoint to get trending niches for the current day.
+    - If today's data exists in Supabase, return it.
+    - Otherwise, fetch from Gemini, store in Supabase, and return the new data.
+    - If Gemini fails, fallback to the most recent data available.
+    """
+    today = str(date.today())
+    # Check if today's data exists in Supabase
+    result = supabase.table("trending_niches").select("*").eq("fetched_at", today).execute()
+    if not result.data:
+        # Fetch from Gemini and store
+        try:
+            niches = fetch_from_gemini()
+            for niche in niches:
+                supabase.table("trending_niches").insert({
+                    "name": niche["name"],
+                    "insight": niche["insight"],
+                    "global_activity": int(niche["global_activity"]),
+                    "fetched_at": today
+                }).execute()
+            result = supabase.table("trending_niches").select("*").eq("fetched_at", today).execute()
+        except Exception as e:
+            print("Gemini fetch failed:", e)
+            # fallback: serve most recent data
+            result = supabase.table("trending_niches").select("*").order("fetched_at", desc=True).limit(6).execute()
+    return result.data
+
+youtube_router = APIRouter(prefix="/youtube", tags=["YouTube"])
+
+@youtube_router.get("/channel-info")
+def get_youtube_channel_info(channelId: str = Query(..., description="YouTube Channel ID")):
+    """
+    Proxy endpoint to fetch YouTube channel info securely from the backend.
+    The API key is kept secret and rate limiting can be enforced here.
+    """
+    api_key = os.getenv("YOUTUBE_API_KEY")
+    if not api_key:
+        raise HTTPException(status_code=500, detail="YouTube API key not configured on server.")
+    url = f"https://www.googleapis.com/youtube/v3/channels?part=snippet,statistics&id={channelId}&key={api_key}"
+    try:
+        resp = requests.get(url, timeout=10)
+        resp.raise_for_status()
+        return resp.json()
+    except requests.RequestException as e:
+        raise HTTPException(status_code=502, detail=f"YouTube API error: {str(e)}")

Backend/app/routes/auth.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+@router.get("/auth/ping")
+def ping():
+    return {"message": "Auth route is working!"}

Backend/app/routes/chat.py

@@ -7,12 +7,12 @@
     HTTPException,
 )
 from sqlalchemy.ext.asyncio import AsyncSession
-from db.db import get_db
-from services.chat_services import chat_service
+from ..db.db import get_db
+from ..services.chat_services import chat_service
 from redis.asyncio import Redis
-from services.redis_client import get_redis
+from ..services.redis_client import get_redis
 import asyncio
-from services.chat_pubsub import listen_to_channel
+from ..services.chat_pubsub import listen_to_channel
 
 router = APIRouter(prefix="/chat", tags=["Chat"])
 

Backend/app/routes/match.py

@@ -0,0 +1,29 @@
+from fastapi import APIRouter, HTTPException
+from supabase import create_client, Client
+import os
+from dotenv import load_dotenv
+from ..services.db_service import match_creators_for_brand, match_brands_for_creator
+
+# Load environment variables
+# load_dotenv()
+# url: str = os.getenv("SUPABASE_URL")
+# key: str = os.getenv("SUPABASE_KEY")
+# supabase: Client = create_client(url, key)
+
+router = APIRouter(prefix="/match", tags=["Matching"])
+
+@router.get("/creators-for-brand/{sponsorship_id}")
+def get_creators_for_brand(sponsorship_id: str):
+    matches = match_creators_for_brand(sponsorship_id)
+    if not matches:
+        raise HTTPException(status_code=404, detail="No matching creators found.")
+    return {"matches": matches}
+
+@router.get("/brands-for-creator/{creator_id}")
+def get_brands_for_creator(creator_id: str):
+    matches = match_brands_for_creator(creator_id)
+    if not matches:
+        raise HTTPException(status_code=404, detail="No matching brand campaigns found.")
+    return {"matches": matches}
+
+# Placeholder for endpoints, logic to be added next 

Backend/app/routes/post.py

@@ -1,12 +1,12 @@
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.future import select
-from db.db import AsyncSessionLocal
-from models.models import (
+from ..db.db import AsyncSessionLocal
+from ..models.models import (
     User, AudienceInsights, Sponsorship, UserPost,
     SponsorshipApplication, SponsorshipPayment, Collaboration
 )
-from schemas.schema import (
+from ..schemas.schema import (
     UserCreate, AudienceInsightsCreate, SponsorshipCreate, UserPostCreate,
     SponsorshipApplicationCreate, SponsorshipPaymentCreate, CollaborationCreate
 )
@@ -44,7 +44,6 @@ async def create_user(user: UserCreate):
         "id": user_id,
         "username": user.username,
         "email": user.email,
-        "password_hash": user.password_hash,
         "role": user.role,
         "profile_image": user.profile_image,
         "bio": user.bio,

Backend/app/schemas/schema.py

@@ -5,7 +5,6 @@
 class UserCreate(BaseModel):
     username: str
     email: str
-    password_hash: str
     role: str
     profile_image: Optional[str] = None
     bio: Optional[str] = None

Backend/app/services/chat_services.py

@@ -2,8 +2,8 @@
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.sql import select
 from datetime import datetime, timezone
-from models.models import User
-from models.chat import ChatList, ChatMessage, MessageStatus
+from app.models.models import User
+from app.models.chat import ChatList, ChatMessage, MessageStatus
 from typing import Dict
 from redis.asyncio import Redis
 import logging