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,5 @@ port=5432
 dbname=postgres
 GROQ_API_KEY=
 SUPABASE_URL=
-SUPABASE_KEY=
+SUPABASE_KEY=
+GEMINI_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,8 @@ 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.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
 
 
@@ -31,14 +32,10 @@ class User(Base):
     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,66 @@
+# FastAPI router for AI-powered endpoints, including trending niches
+from fastapi import APIRouter
+from datetime import date
+import os
+import requests
+import json
+from supabase import create_client, Client
+
+# 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")
+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}"
+    resp = requests.post(url, json={"contents": [{"parts": [{"text": prompt}]}]})
+    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

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
 )

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

Backend/app/services/db_service.py

@@ -0,0 +1,85 @@
+from supabase import create_client, Client
+import os
+from dotenv import load_dotenv
+from typing import List, Dict, Any
+
+# Load environment variables
+load_dotenv()
+url: str = os.getenv("SUPABASE_URL")
+key: str = os.getenv("SUPABASE_KEY")
+supabase: Client = create_client(url, key)
+
+
+def match_creators_for_brand(sponsorship_id: str) -> List[Dict[str, Any]]:
+    # Fetch sponsorship details
+    sponsorship_resp = supabase.table("sponsorships").select("*").eq("id", sponsorship_id).execute()
+    if not sponsorship_resp.data:
+        return []
+    sponsorship = sponsorship_resp.data[0]
+
+    # Fetch all audience insights (for creators)
+    audience_resp = supabase.table("audience_insights").select("*").execute()
+    creators = []
+    for audience in audience_resp.data:
+        # Basic matching logic: audience, engagement, price, etc.
+        match_score = 0
+        # Audience age group overlap
+        if 'required_audience' in sponsorship and 'audience_age_group' in audience:
+            required_ages = sponsorship['required_audience'].get('age_group', [])
+            creator_ages = audience.get('audience_age_group', {})
+            overlap = sum([creator_ages.get(age, 0) for age in required_ages])
+            if overlap > 0:
+                match_score += 1
+        # Audience location overlap
+        if 'required_audience' in sponsorship and 'audience_location' in audience:
+            required_locs = sponsorship['required_audience'].get('location', [])
+            creator_locs = audience.get('audience_location', {})
+            overlap = sum([creator_locs.get(loc, 0) for loc in required_locs])
+            if overlap > 0:
+                match_score += 1
+        # Engagement rate
+        if audience.get('engagement_rate', 0) >= sponsorship.get('engagement_minimum', 0):
+            match_score += 1
+        # Price expectation
+        if audience.get('price_expectation', 0) <= sponsorship.get('budget', 0):
+            match_score += 1
+        if match_score >= 2:  # Threshold for a match
+            creators.append({"user_id": audience["user_id"], "match_score": match_score, **audience})
+    return creators
+
+
+def match_brands_for_creator(creator_id: str) -> List[Dict[str, Any]]:
+    # Fetch creator's audience insights
+    audience_resp = supabase.table("audience_insights").select("*").eq("user_id", creator_id).execute()
+    if not audience_resp.data:
+        return []
+    audience = audience_resp.data[0]
+
+    # Fetch all sponsorships
+    sponsorships_resp = supabase.table("sponsorships").select("*").execute()
+    matches = []
+    for sponsorship in sponsorships_resp.data:
+        match_score = 0
+        # Audience age group overlap
+        if 'required_audience' in sponsorship and 'audience_age_group' in audience:
+            required_ages = sponsorship['required_audience'].get('age_group', [])
+            creator_ages = audience.get('audience_age_group', {})
+            overlap = sum([creator_ages.get(age, 0) for age in required_ages])
+            if overlap > 0:
+                match_score += 1
+        # Audience location overlap
+        if 'required_audience' in sponsorship and 'audience_location' in audience:
+            required_locs = sponsorship['required_audience'].get('location', [])
+            creator_locs = audience.get('audience_location', {})
+            overlap = sum([creator_locs.get(loc, 0) for loc in required_locs])
+            if overlap > 0:
+                match_score += 1
+        # Engagement rate
+        if audience.get('engagement_rate', 0) >= sponsorship.get('engagement_minimum', 0):
+            match_score += 1
+        # Price expectation
+        if audience.get('price_expectation', 0) <= sponsorship.get('budget', 0):
+            match_score += 1
+        if match_score >= 2:  # Threshold for a match
+            matches.append({"sponsorship_id": sponsorship["id"], "match_score": match_score, **sponsorship})
+    return matches

Backend/sql.txt

@@ -1,8 +1,8 @@
 -- Insert into users table
-INSERT INTO users (id, username, email, password_hash, role, profile_image, bio, created_at) VALUES
-  (gen_random_uuid(), 'creator1', 'creator1@example.com', 'hashedpassword1', 'creator', 'image1.jpg', 'Bio of creator1', NOW()),
-  (gen_random_uuid(), 'brand1', 'brand1@example.com', 'hashedpassword2', 'brand', 'image2.jpg', 'Bio of brand1', NOW()),
-  (gen_random_uuid(), 'creator2', 'creator2@example.com', 'hashedpassword3', 'creator', 'image3.jpg', 'Bio of creator2', NOW());
+INSERT INTO users (id, username, email, role, profile_image, bio, created_at) VALUES
+  (gen_random_uuid(), 'creator1', 'creator1@example.com', 'creator', 'image1.jpg', 'Bio of creator1', NOW()),
+  (gen_random_uuid(), 'brand1', 'brand1@example.com', 'brand', 'image2.jpg', 'Bio of brand1', NOW()),
+  (gen_random_uuid(), 'creator2', 'creator2@example.com', 'creator', 'image3.jpg', 'Bio of creator2', NOW());
 
 -- Insert into audience_insights table
 INSERT INTO audience_insights (id, user_id, audience_age_group, audience_location, engagement_rate, average_views, time_of_attention, price_expectation, created_at) VALUES

Frontend/env-example

@@ -1,2 +1,3 @@
 VITE_SUPABASE_URL=https://your-project.supabase.co
-VITE_SUPABASE_ANON_KEY=your-anon-key-here
+VITE_SUPABASE_ANON_KEY=your-anon-key-here
+VITE_YOUTUBE_API_KEY=your-youtube-api-key-here