Upload backend code and PyTorch weights

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+backend/__pycache__/api_routes.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text

backend/__pycache__/api_routes.cpython-313.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba4cd72be3aca9ed555b38531910b78128c75c9bd7e9c027ff0ec714c55f5a10
+size 100417

backend/core/config.py

@@ -0,0 +1,29 @@
+import os
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Base directory points to the backend/ folder
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+DOG_SKIN_MODEL = os.path.join(BASE_DIR, "weights/dog_skin_model.pth")
+DOG_EYE_MODEL = os.path.join(BASE_DIR, "weights/dog_eye_model_ResNet_NEW.pth")
+CAT_SKIN_MODEL = os.path.join(BASE_DIR, "weights/cat_skin_model.pth")
+
+DEVICE = "cuda" if __import__("torch").cuda.is_available() else "cpu"
+
+# Supabase Configurations
+SUPABASE_URL = os.getenv("SUPABASE_URL", "")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY", "")
+SUPABASE_SERVICE_KEY = os.getenv("SUPABASE_SERVICE_KEY", "")
+
+# Admin Credentials
+ADMIN_EMAIL = os.getenv("ADMIN_EMAIL", "admin@petai.com")
+ADMIN_PASSWORD = os.getenv("ADMIN_PASSWORD", "AdminPass!234")
+
+# LangSmith Configuration (for tracing and debugging)
+LANGCHAIN_TRACING_V2 = os.getenv("LANGCHAIN_TRACING_V2", "false").lower() == "true"
+LANGCHAIN_API_KEY = os.getenv("LANGCHAIN_API_KEY", None)
+LANGCHAIN_ENDPOINT = os.getenv("LANGCHAIN_ENDPOINT", "https://api.smith.langchain.com")
+LANGCHAIN_PROJECT = os.getenv("LANGCHAIN_PROJECT", "Pet_AI")

backend/core/dependencies.py

@@ -0,0 +1,66 @@
+from fastapi import Request, Depends, HTTPException, status
+from fastapi.security import HTTPAuthorizationCredentials
+from backend.core.security import verify_supabase_jwt, security_scheme
+from chatbot.supabase_config import supabase
+from typing import Dict, List, Optional
+
+async def get_current_user(
+    credentials: Optional[HTTPAuthorizationCredentials] = Depends(security_scheme)
+) -> Dict:
+    """
+    Dependency to get the currently authenticated user.
+    Verifies the JWT and fetches their profile from public.users.
+    """
+    if not credentials:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Authentication credentials missing"
+        )
+    
+    token = credentials.credentials
+    # Verify JWT via Supabase Auth
+    user_data = verify_supabase_jwt(token)
+    user_id = user_data["id"]
+    
+    # Query the public.users table to get the latest role and status
+    try:
+        user_response = supabase.table("users").select("*").eq("id", user_id).execute()
+        if not user_response.data:
+            # Fallback to metadata if user doesn't exist yet (e.g., during signup)
+            return user_data
+            
+        db_user = user_response.data[0]
+        
+        # Return merged user data
+        return {
+            "id": user_id,
+            "email": user_data["email"],
+            "role": db_user.get("role", "owner"),
+            "phone": db_user.get("phone_number", ""),
+            "full_name": db_user.get("full_name", ""),
+            "avatar_url": db_user.get("avatar_url", "")
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        # Fallback to verified JWT data if DB query fails
+        return user_data
+
+class RoleChecker:
+    def __init__(self, allowed_roles: List[str]):
+        self.allowed_roles = allowed_roles
+        
+    def __call__(self, current_user: Dict = Depends(get_current_user)) -> Dict:
+        if current_user["role"] not in self.allowed_roles:
+            raise HTTPException(
+                status_code=status.HTTP_403_FORBIDDEN,
+                detail=f"Access denied. Required role(s): {', '.join(self.allowed_roles)}"
+            )
+        return current_user
+
+# Helper dependency builders
+def require_role(role: str):
+    return Depends(RoleChecker([role]))
+
+def require_any_role(roles: List[str]):
+    return Depends(RoleChecker(roles))

backend/core/security.py

@@ -0,0 +1,41 @@
+from fastapi import Request, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from typing import Optional, Dict
+import logging
+from chatbot.supabase_config import supabase
+
+logger = logging.getLogger(__name__)
+
+security_scheme = HTTPBearer(auto_error=False)
+
+def verify_supabase_jwt(token: str) -> Dict:
+    """
+    Verify Supabase JWT token using the Supabase auth client.
+    Returns the user data dict if valid.
+    Raises HTTPException 401 if invalid/expired.
+    """
+    try:
+        # get_user verifies the token against the Supabase Auth server
+        response = supabase.auth.get_user(token)
+        if not response or not response.user:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Invalid or expired authentication token"
+            )
+        
+        user = response.user
+        # Convert user object to dictionary
+        user_data = {
+            "id": user.id,
+            "email": user.email,
+            "role": user.user_metadata.get("role", "owner") if user.user_metadata else "owner",
+            "phone": user.user_metadata.get("phone", "") if user.user_metadata else "",
+            "is_active": user.user_metadata.get("is_active", True) if user.user_metadata else True
+        }
+        return user_data
+    except Exception as e:
+        logger.error(f"JWT verification failed: {str(e)}")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail=f"Authentication failed: {str(e)}"
+        )

backend/main.py

@@ -0,0 +1,210 @@
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import logging
+import tempfile
+import os
+
+# Import models & services with updated backend package prefix
+from backend.models import dog_skin, dog_eye, cat_skin
+from backend.utils.image import preprocess
+from backend.services.router import route_prediction
+
+# Import refactored routers
+from backend.routers.auth import router as auth_router
+from backend.routers.pets import router as pets_router
+from backend.routers.appointments import router as appointments_router
+from backend.routers.clinics import router as clinics_router
+from backend.routers.admin import router as admin_router
+
+from chatbot.langsmith_config import setup_langsmith
+from chatbot.tools import _analyze_pet_image_impl
+from chatbot.rag.agentic_rag import query_agentic_rag
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="Pet PULSE Disease Detection API")
+
+# Enable CORS for frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:3000",
+        "http://localhost:3001",
+        "http://127.0.0.1:3000",
+        "http://127.0.0.1:3001",
+        "*",
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include refactored routers under the /api prefix
+app.include_router(auth_router, prefix="/api")
+app.include_router(pets_router, prefix="/api")
+app.include_router(appointments_router, prefix="/api")
+app.include_router(clinics_router, prefix="/api")
+app.include_router(admin_router, prefix="/api")
+
+# 🏠 Root endpoint
+@app.get("/")
+async def root():
+    """Root endpoint with API information"""
+    return {
+        "name": "Pet PULSE Disease Detection API",
+        "version": "1.0.0",
+        "docs": "http://localhost:8000/docs",
+        "status": "running",
+        "endpoints": {
+            "prediction": "/predict",
+            "image_analysis": "/analyze-image",
+            "pets": "/api/pets",
+            "clinics": "/api/clinics"
+        }
+    }
+
+# 🏥 Health check endpoint
+@app.get("/health")
+async def health():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "service": "Pet PULSE API",
+        "models_loaded": {
+            "dog_skin": hasattr(app.state, 'dog_skin') and app.state.dog_skin is not None,
+            "dog_eye": hasattr(app.state, 'dog_eye') and app.state.dog_eye is not None,
+            "cat_skin": hasattr(app.state, 'cat_skin') and app.state.cat_skin is not None
+        }
+    }
+
+# 🔥 Load models ONCE on startup
+@app.on_event("startup")
+def load_models():
+    try:
+        # Initialize LangSmith tracing (optional)
+        setup_langsmith()
+        logger.info("LangSmith tracing initialized")
+    except Exception as e:
+        logger.warning(f"LangSmith initialization failed (optional): {e}")
+    
+    try:
+        app.state.dog_skin = dog_skin.load_model()
+        logger.info("Dog skin model loaded")
+    except Exception as e:
+        logger.warning(f"Dog skin model loading failed: {e}")
+        app.state.dog_skin = None
+    
+    try:
+        app.state.dog_eye = dog_eye.load_model()
+        logger.info("Dog eye model loaded")
+    except Exception as e:
+        logger.warning(f"Dog eye model loading failed: {e}")
+        app.state.dog_eye = None
+    
+    try:
+        app.state.cat_skin = cat_skin.load_model()
+        logger.info("Cat skin model loaded")
+    except Exception as e:
+        logger.warning(f"Cat skin model loading failed: {e}")
+        app.state.cat_skin = None
+    
+    logger.info("✅ Backend startup complete")
+
+# 📸 Prediction endpoint
+@app.post("/predict")
+async def predict(
+    file: UploadFile = File(...),
+    animal: str = Form(...),
+    disease_type: str = Form(...)
+):
+    image = preprocess(file.file)
+    result = route_prediction(app, animal, disease_type, image)
+    return result
+
+# 🔍 Analyze image endpoint (for chatbot integration)
+@app.post("/analyze-image")
+async def analyze_image(
+    file: UploadFile = File(...),
+    disease_type: str = Form(...),
+    animal: str = Form("dog"),
+    user_id: str = Form("demo")
+):
+    """
+    Analyze pet image for disease detection.
+    Used by chatbot for skin/eye disease diagnosis.
+    """
+    image = preprocess(file.file)
+    result = route_prediction(app, animal, disease_type, image)
+    return result
+
+# 📸 Chatbot image upload endpoint
+@app.post("/api/chat/upload-image")
+async def upload_image(
+    session_id: str = Form(...),
+    disease_type: str = Form(...),
+    file: UploadFile = File(...)
+):
+    """
+    Upload and analyze a pet image for chatbot.
+    """
+    try:
+        animal = "dog"  # Default - in production, retrieve from session
+        
+        if disease_type not in ["skin", "eye"]:
+            raise HTTPException(status_code=400, detail="disease_type must be 'skin' or 'eye'")
+        
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as tmp:
+            content = await file.read()
+            tmp.write(content)
+            tmp_path = tmp.name
+        
+        try:
+            tool_result = _analyze_pet_image_impl(
+                image_path=tmp_path,
+                animal=animal,
+                disease_type=disease_type
+            )
+            
+            if isinstance(tool_result, dict) and "error" in tool_result:
+                raise HTTPException(status_code=400, detail=tool_result['error'])
+            
+            disease_class = tool_result.get('class', 'Unknown')
+            confidence = tool_result.get('confidence', 0.0)
+            
+            explanation_query = f"""The computer vision model detected {disease_class} (confidence: {confidence:.1%}) from a {animal}'s {disease_type} image.
+
+Provide a detailed veterinary explanation covering:
+1. What is {disease_class}?
+2. Common causes and risk factors for this condition
+3. Treatment options and recommendations
+4. When to seek professional veterinary care
+5. Prevention and management tips
+
+Be thorough and informative. Use formatting with headers and bullet points for clarity."""
+            
+            explanation_text = query_agentic_rag(
+                question=explanation_query,
+                chat_history="",
+                force_rag=True
+            )
+            
+            logger.info(f"Image analyzed for {disease_type}: {disease_class}")
+            
+            return {
+                "session_id": session_id,
+                "disease_class": disease_class,
+                "confidence": confidence,
+                "explanation": explanation_text
+            }
+        
+        finally:
+            if os.path.exists(tmp_path):
+                os.remove(tmp_path)
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error uploading image: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

backend/models/cat_skin.py

@@ -0,0 +1,18 @@
+import torch
+import torch.nn as nn
+from torchvision import models
+from backend.core.config import CAT_SKIN_MODEL, DEVICE
+
+class_names = ["Flea_Allergy", "Health", "Ringworm", "Scabies"]
+
+def load_model():
+    model = models.resnet50(pretrained=False)
+    model.fc = nn.Linear(model.fc.in_features, len(class_names))
+
+    checkpoint = torch.load(CAT_SKIN_MODEL, map_location=DEVICE)
+    model.load_state_dict(checkpoint['model_state_dict'])
+
+    model.to(DEVICE)
+    model.eval()
+
+    return model, class_names

backend/models/dog_eye.py

@@ -0,0 +1,24 @@
+import torch
+import torch.nn as nn
+from torchvision import models
+from backend.core.config import DOG_EYE_MODEL, DEVICE
+
+class_names = [
+    "Pigmented keratitis",
+    "blepharitis",
+    "entropion",
+    "eyelid_tumor",
+    "mastopathy"
+]
+
+def load_model():
+    model = models.resnet50(pretrained=False)
+    model.fc = nn.Linear(model.fc.in_features, len(class_names))
+
+    checkpoint = torch.load(DOG_EYE_MODEL, map_location=DEVICE)
+    model.load_state_dict(checkpoint['model_state_dict'])
+
+    model.to(DEVICE)
+    model.eval()
+
+    return model, class_names

backend/models/dog_skin.py

@@ -0,0 +1,25 @@
+import torch
+import torch.nn as nn
+from torchvision import models
+from backend.core.config import DOG_SKIN_MODEL, DEVICE
+
+class_names = [
+    "Dermatitis",
+    "Fungal_infections",
+    "Healthy",
+    "Hypersensitivity",
+    "demodicosis",
+    "ringworm"
+]
+
+def load_model():
+    model = models.resnet50(pretrained=False)
+    model.fc = nn.Linear(model.fc.in_features, len(class_names))
+
+    checkpoint = torch.load(DOG_SKIN_MODEL, map_location=DEVICE)
+    model.load_state_dict(checkpoint['model_state_dict'])
+
+    model.to(DEVICE)
+    model.eval()
+
+    return model, class_names

backend/routers/admin.py

@@ -0,0 +1,104 @@
+from fastapi import APIRouter, Depends, HTTPException, Request
+from typing import Optional
+import logging
+from backend.core.dependencies import require_role
+from backend.services.clinic_service import ClinicService
+
+logger = logging.getLogger(__name__)
+
+# Protect the entire router with require_role("admin")
+router = APIRouter(prefix="/admin", tags=["Admin Operations"], dependencies=[require_role("admin")])
+
+@router.get("/clinics/pending")
+async def get_pending_clinics():
+    """List all pending clinics (unverified and not rejected)"""
+    logger.info("Admin: Fetching pending clinics")
+    result = ClinicService.get_pending_clinics()
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+    return result
+
+@router.get("/clinics")
+async def get_all_clinics():
+    """List all clinics with their derived verification status"""
+    logger.info("Admin: Fetching all clinics")
+    result = ClinicService.get_public_clinics()  # We can fetch all or public
+    # Let's query all clinics from Supabase directly for admin
+    from chatbot.supabase_config import supabase
+    try:
+        resp = supabase.table("clinics").select("*").order("created_at", desc=True).execute()
+        clinics = [ClinicService._parse_clinic_status(c) for c in (resp.data or [])]
+        return {"success": True, "clinics": clinics, "count": len(clinics)}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.get("/stats")
+async def get_admin_stats():
+    """Return admin dashboard counts and recent clinic activity"""
+    logger.info("Admin: Fetching dashboard stats")
+    
+    from chatbot.supabase_config import supabase
+    try:
+        all_resp = supabase.table("clinics").select("id", "is_verified", "clinic_name", "created_at", "description").execute()
+        clinics = [ClinicService._parse_clinic_status(c) for c in (all_resp.data or [])]
+        
+        total_clinics = len(clinics)
+        approved_clinics = sum(1 for c in clinics if c.get("verification_status") == "approved")
+        pending_clinics = sum(1 for c in clinics if c.get("verification_status") == "pending")
+        rejected_clinics = sum(1 for c in clinics if c.get("verification_status") == "rejected")
+
+        recent = sorted(clinics, key=lambda c: c.get("created_at") or "", reverse=True)[:3]
+        recent_verifications = []
+        for clinic in recent:
+            recent_verifications.append({
+                "clinic": clinic.get("clinic_name", "Unknown Clinic"),
+                "action": clinic.get("verification_status", "pending").title(),
+                "time": clinic.get("created_at"),
+                "badge": (
+                    "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400"
+                    if clinic.get("verification_status") == "approved"
+                    else "bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400"
+                    if clinic.get("verification_status") == "rejected"
+                    else "bg-amber-100 text-amber-700 dark:bg-amber-900/30 dark:text-amber-400"
+                ),
+            })
+
+        return {
+            "success": True,
+            "stats": {
+                "total_clinics": total_clinics,
+                "pending_verifications": pending_clinics,
+                "approved_clinics": approved_clinics,
+                "rejected": rejected_clinics,
+            },
+            "recent_verifications": recent_verifications,
+        }
+    except Exception as e:
+        logger.error(f"Error fetching admin stats: {str(e)}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/clinics/{clinic_id}/approve")
+async def approve_clinic(clinic_id: str):
+    """Approve a clinic (verify it and activate its login profile)"""
+    logger.info(f"Admin: Approving clinic {clinic_id}")
+    result = ClinicService.approve_clinic(clinic_id=clinic_id)
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+    return result
+
+@router.post("/clinics/{clinic_id}/reject")
+async def reject_clinic(clinic_id: str, request: Request):
+    """Reject a clinic registration with an optional reason"""
+    logger.info(f"Admin: Rejecting clinic {clinic_id}")
+    
+    # Read optional reason from request body
+    try:
+        body = await request.json()
+    except Exception:
+        body = {}
+    reason = (body or {}).get("reason")
+
+    result = ClinicService.reject_clinic(clinic_id=clinic_id, reason=reason)
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+    return result

backend/routers/appointments.py

@@ -0,0 +1,171 @@
+from fastapi import APIRouter, Depends, HTTPException, status, Form
+from typing import Optional
+import logging
+from backend.core.dependencies import get_current_user
+from backend.schemas.schemas import CreateAppointmentRequest, CreateReviewRequest
+from backend.services.appointment_service import AppointmentService
+from chatbot.supabase_config import supabase
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["Appointments & Reviews"])
+
+@router.post("/appointments")
+async def create_appointment(
+    request: CreateAppointmentRequest,
+    current_user: dict = Depends(get_current_user)
+):
+    """Create a new appointment"""
+    logger.info(f"Creating appointment for pet {request.pet_id} by user: {current_user['id']}")
+    
+    # Check authorization: If owner, must be the owner of the pet
+    if current_user["role"] == "owner":
+        pet_resp = supabase.table("pets").select("user_id").eq("id", request.pet_id).execute()
+        if not pet_resp.data or pet_resp.data[0]["user_id"] != current_user["id"]:
+            raise HTTPException(status_code=403, detail="You can only schedule appointments for your own pets")
+
+    result = AppointmentService.create_appointment(
+        pet_id=request.pet_id,
+        clinic_id=request.clinic_id,
+        owner_id=current_user["id"] if current_user["role"] == "owner" else request.owner_id,
+        appointment_date=request.appointment_date,
+        appointment_time=request.appointment_time,
+        reason=request.reason,
+        notes=request.notes,
+    )
+    
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+        
+    return result
+
+@router.get("/appointments/owner")
+async def get_owner_appointments(
+    owner_id: Optional[str] = None,
+    current_user: dict = Depends(get_current_user)
+):
+    """Get appointments for a pet owner"""
+    target_owner_id = owner_id or current_user["id"]
+    
+    # Check authorization: Owners can only view their own appointments
+    if current_user["role"] == "owner" and target_owner_id != current_user["id"]:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    result = AppointmentService.get_owner_appointments(owner_id=target_owner_id)
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+        
+    return result
+
+@router.get("/appointments/clinic")
+async def get_clinic_appointments(
+    clinic_id: str,
+    current_user: dict = Depends(get_current_user)
+):
+    """Get appointments for a clinic"""
+    # Check authorization: Clinics can only view their own appointments
+    if current_user["role"] == "clinic":
+        # Get the clinic's ID from user_id
+        clinic_resp = supabase.table("clinics").select("id").eq("user_id", current_user["id"]).execute()
+        if not clinic_resp.data or clinic_resp.data[0]["id"] != clinic_id:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+    result = AppointmentService.get_clinic_appointments(clinic_id=clinic_id)
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+        
+    return result
+
+@router.get("/appointments/pet")
+async def get_pet_appointments(
+    pet_id: str,
+    current_user: dict = Depends(get_current_user)
+):
+    """Get all appointments for a pet"""
+    # Check authorization: Owners can only view appointments for their own pets
+    if current_user["role"] == "owner":
+        pet_resp = supabase.table("pets").select("user_id").eq("id", pet_id).execute()
+        if not pet_resp.data or pet_resp.data[0]["user_id"] != current_user["id"]:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+    result = AppointmentService.get_pet_appointments(pet_id=pet_id)
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+        
+    return result
+
+@router.post("/appointments/{appointment_id}/status")
+async def update_appointment_status(
+    appointment_id: str,
+    status: str = Form(...),
+    current_user: dict = Depends(get_current_user)
+):
+    """Update status of an appointment"""
+    # Validate status
+    valid_statuses = {"scheduled", "completed", "cancelled", "in_progress"}
+    if status not in valid_statuses:
+        raise HTTPException(status_code=400, detail="Invalid status value")
+
+    # Check authorization
+    appt_resp = supabase.table("appointments").select("owner_id", "clinic_id").eq("id", appointment_id).execute()
+    if not appt_resp.data:
+        raise HTTPException(status_code=404, detail="Appointment not found")
+    
+    appt = appt_resp.data[0]
+    
+    if current_user["role"] == "owner":
+        if appt["owner_id"] != current_user["id"]:
+            raise HTTPException(status_code=403, detail="Access denied")
+        if status != "cancelled":
+            raise HTTPException(status_code=403, detail="Owners can only cancel appointments")
+    elif current_user["role"] == "clinic":
+        clinic_resp = supabase.table("clinics").select("id").eq("user_id", current_user["id"]).execute()
+        if not clinic_resp.data or clinic_resp.data[0]["id"] != appt["clinic_id"]:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+    result = AppointmentService.update_appointment_status(appointment_id=appointment_id, status=status)
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+        
+    return result
+
+@router.post("/reviews")
+async def create_review(
+    request: CreateReviewRequest,
+    current_user: dict = Depends(get_current_user)
+):
+    """Create a clinic review for a completed appointment"""
+    if current_user["role"] != "owner":
+        raise HTTPException(status_code=403, detail="Only pet owners can review clinics")
+
+    # Check authorization: Must be the owner of the appointment
+    appt_resp = supabase.table("appointments").select("owner_id").eq("id", request.appointment_id).execute()
+    if not appt_resp.data:
+        raise HTTPException(status_code=404, detail="Appointment not found")
+    
+    if appt_resp.data[0]["owner_id"] != current_user["id"]:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    result = AppointmentService.create_review(
+        appointment_id=request.appointment_id,
+        rating=request.rating,
+        treatment=request.treatment,
+        comment=request.comment
+    )
+    
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+        
+    return result
+
+@router.get("/reviews/clinic")
+async def get_reviews_for_clinic(
+    clinic_id: str,
+    current_user: dict = Depends(get_current_user)
+):
+    """Get all reviews for a clinic"""
+    result = AppointmentService.get_reviews_for_clinic(clinic_id=clinic_id)
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+        
+    return result

backend/routers/auth.py

@@ -0,0 +1,254 @@
+from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, File, Form
+from typing import Optional
+import logging
+import time
+import os
+from datetime import datetime
+from backend.core.dependencies import get_current_user
+from backend.schemas.schemas import RegisterOwnerRequest, RegisterClinicRequest, NotificationReadRequest
+from backend.services.auth_service import AuthService
+from chatbot.supabase_config import supabase, SupabaseStorage
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/auth", tags=["Authentication & Notifications"])
+
+@router.post("/register/owner")
+async def register_owner(
+    request: RegisterOwnerRequest,
+    current_user: dict = Depends(get_current_user)
+):
+    """Complete registration of a new pet owner profile"""
+    logger.info(f"Registering pet owner profile for user: {current_user['id']}")
+    
+    result = AuthService.register_pet_owner(
+        user_id=current_user["id"],
+        email=current_user["email"],
+        first_name=request.first_name,
+        last_name=request.last_name,
+        phone=request.phone,
+        address=request.address,
+        state=request.state,
+        zip_code=request.zip_code,
+        country=request.country,
+        bio=request.bio,
+    )
+    
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+        
+    return result
+
+@router.post("/register/clinic")
+async def register_clinic(
+    clinic_name: str = Form(...),
+    phone: str = Form(...),
+    address: str = Form(...),
+    city: Optional[str] = Form(None),
+    state: Optional[str] = Form(None),
+    zip_code: Optional[str] = Form(None),
+    country: Optional[str] = Form(None),
+    website: Optional[str] = Form(None),
+    opening_hours: Optional[str] = Form(None),
+    description: Optional[str] = Form(None),
+    clinic_photo: Optional[UploadFile] = File(None),
+    clinic_license: Optional[UploadFile] = File(None),
+    latitude: Optional[float] = Form(None),
+    longitude: Optional[float] = Form(None),
+    current_user: dict = Depends(get_current_user)
+):
+    """Complete registration of a new clinic profile"""
+    logger.info(f"Registering clinic profile for user: {current_user['id']}")
+    
+    clinic_logo_url = None
+    license_document_url = None
+
+    # Handle image upload
+    if clinic_photo and clinic_photo.filename:
+        if not clinic_photo.content_type or not clinic_photo.content_type.startswith("image/"):
+            raise HTTPException(status_code=400, detail="Scale photo must be an image")
+        
+        photo_bytes = await clinic_photo.read()
+        photo_ext = os.path.splitext(clinic_photo.filename)[1] or ".jpg"
+        photo_name = f"{clinic_name.replace(' ', '_')}-{int(time.time())}{photo_ext}"
+        photo_path = SupabaseStorage.upload_clinic_image(
+            user_id=current_user["id"],
+            file_data=photo_bytes,
+            filename=photo_name,
+            content_type=clinic_photo.content_type or "image/jpeg"
+        )
+        clinic_logo_url = supabase.storage.from_("clinic-images").get_public_url(photo_path)
+
+    # Handle license upload
+    if clinic_license and clinic_license.filename:
+        valid_types = ["image/jpeg", "image/png", "image/jpg", "application/pdf"]
+        if clinic_license.content_type and clinic_license.content_type not in valid_types:
+            raise HTTPException(status_code=400, detail="License must be a PDF or image (JPG/PNG)")
+            
+        license_bytes = await clinic_license.read()
+        license_ext = os.path.splitext(clinic_license.filename)[1] or ".pdf"
+        license_name = f"license-{clinic_name.replace(' ', '_')}-{int(time.time())}{license_ext}"
+        license_path = SupabaseStorage.upload_clinic_document(
+            user_id=current_user["id"],
+            file_data=license_bytes,
+            filename=license_name,
+            content_type=clinic_license.content_type or "application/pdf"
+        )
+        license_document_url = supabase.storage.from_("clinic-documents").get_public_url(license_path)
+
+    result = AuthService.register_clinic(
+        user_id=current_user["id"],
+        email=current_user["email"],
+        clinic_name=clinic_name,
+        phone=phone,
+        address=address,
+        city=city,
+        state=state,
+        zip_code=zip_code,
+        country=country,
+        website=website,
+        opening_hours=opening_hours,
+        description=description,
+        clinic_logo_url=clinic_logo_url,
+        license_document_url=license_document_url,
+        latitude=latitude,
+        longitude=longitude,
+    )
+    
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+        
+    return result
+
+@router.get("/profile")
+async def get_profile(current_user: dict = Depends(get_current_user)):
+    """Get the current authenticated user's profile"""
+    result = AuthService.get_user_profile(current_user["id"])
+    if not result["success"]:
+        raise HTTPException(status_code=404, detail=result.get("error"))
+    return result
+
+@router.put("/profile")
+async def update_profile(
+    full_name: Optional[str] = Form(None),
+    phone: Optional[str] = Form(None),
+    address: Optional[str] = Form(None),
+    state: Optional[str] = Form(None),
+    zip_code: Optional[str] = Form(None),
+    country: Optional[str] = Form(None),
+    bio: Optional[str] = Form(None),
+    emergency_contact_name: Optional[str] = Form(None),
+    emergency_contact_phone: Optional[str] = Form(None),
+    photo: Optional[UploadFile] = File(None),
+    latitude: Optional[float] = Form(None),
+    longitude: Optional[float] = Form(None),
+    current_user: dict = Depends(get_current_user)
+):
+    """Update pet owner profile details"""
+    profile_image_url = None
+    
+    if photo and photo.filename:
+        if not photo.content_type or not photo.content_type.startswith("image/"):
+            raise HTTPException(status_code=400, detail="Profile photo must be an image")
+        
+        photo_bytes = await photo.read()
+        photo_ext = os.path.splitext(photo.filename)[1] or ".jpg"
+        photo_name = f"avatar-{int(time.time())}{photo_ext}"
+        photo_path = SupabaseStorage.upload_user_avatar(
+            user_id=current_user["id"],
+            file_data=photo_bytes,
+            filename=photo_name,
+            content_type=photo.content_type or "image/jpeg"
+        )
+        profile_image_url = supabase.storage.from_("user-avatars").get_public_url(photo_path)
+
+    updates = {}
+    if full_name is not None:
+        updates["full_name"] = full_name
+    if phone is not None:
+        updates["phone"] = phone
+    if address is not None:
+        updates["address"] = address
+    if state is not None:
+        updates["state"] = state
+    if zip_code is not None:
+        updates["zip_code"] = zip_code
+    if country is not None:
+        updates["country"] = country
+    if bio is not None:
+        updates["bio"] = bio
+    if emergency_contact_name is not None:
+        updates["emergency_contact_name"] = emergency_contact_name
+    if emergency_contact_phone is not None:
+        updates["emergency_contact_phone"] = emergency_contact_phone
+    if profile_image_url is not None:
+        updates["profile_image_url"] = profile_image_url
+    if latitude is not None:
+        updates["latitude"] = latitude
+    if longitude is not None:
+        updates["longitude"] = longitude
+
+    result = AuthService.update_user_profile(user_id=current_user["id"], updates=updates)
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+        
+    return result
+
+# ============================================
+# Notification Endpoints
+# ============================================
+
+@router.get("/notifications")
+async def get_notifications(limit: int = 20, current_user: dict = Depends(get_current_user)):
+    """Get notifications for the current authenticated user"""
+    logger.info(f"Fetching notifications for user: {current_user['id']}")
+    try:
+        response = (
+            supabase.table("notifications")
+            .select("*")
+            .eq("user_id", current_user["id"])
+            .order("created_at", desc=True)
+            .limit(limit)
+            .execute()
+        )
+        notifications = response.data or []
+        unread_count = sum(1 for item in notifications if not item.get("is_read"))
+        return {"success": True, "notifications": notifications, "count": len(notifications), "unread_count": unread_count}
+    except Exception as e:
+        logger.error(f"Error fetching notifications: {str(e)}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/notifications/{notification_id}/read")
+async def mark_notification_read(notification_id: str, current_user: dict = Depends(get_current_user)):
+    """Mark a single notification as read"""
+    try:
+        # Check authorization
+        notif_resp = supabase.table("notifications").select("user_id").eq("id", notification_id).execute()
+        if not notif_resp.data or notif_resp.data[0]["user_id"] != current_user["id"]:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+        supabase.table("notifications").update({
+            "is_read": True, 
+            "read_at": datetime.utcnow().isoformat()
+        }).eq("id", notification_id).execute()
+        
+        return {"success": True, "notification_id": notification_id}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error marking notification read: {str(e)}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.post("/notifications/read-all")
+async def mark_all_notifications_read(current_user: dict = Depends(get_current_user)):
+    """Mark all notifications for the current user as read"""
+    try:
+        supabase.table("notifications").update({
+            "is_read": True, 
+            "read_at": datetime.utcnow().isoformat()
+        }).eq("user_id", current_user["id"]).eq("is_read", False).execute()
+        
+        return {"success": True, "user_id": current_user["id"]}
+    except Exception as e:
+        logger.error(f"Error marking all notifications read: {str(e)}")
+        raise HTTPException(status_code=400, detail=str(e))

backend/routers/clinics.py

@@ -0,0 +1,173 @@
+from fastapi import APIRouter, Depends, HTTPException, status, Form, UploadFile, File
+from typing import Optional, List
+import logging
+import time
+import os
+from backend.core.dependencies import get_current_user, require_role
+from backend.services.clinic_service import ClinicService
+from chatbot.supabase_config import supabase, SupabaseStorage
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["Clinics"])
+
+@router.get("/clinic/profile")
+async def get_clinic_profile(current_user: dict = Depends(get_current_user)):
+    """Get the current logged-in clinic's profile details"""
+    if current_user["role"] != "clinic":
+        raise HTTPException(status_code=403, detail="Access denied. Clinic role required.")
+
+    result = ClinicService.get_clinic_profile(user_id=current_user["id"])
+    if not result["success"]:
+        raise HTTPException(status_code=404, detail=result.get("error"))
+    return result
+
+@router.put("/clinic/profile")
+async def update_clinic_profile(
+    clinic_name: Optional[str] = Form(None),
+    phone: Optional[str] = Form(None),
+    address: Optional[str] = Form(None),
+    city: Optional[str] = Form(None),
+    state: Optional[str] = Form(None),
+    zip_code: Optional[str] = Form(None),
+    country: Optional[str] = Form(None),
+    website: Optional[str] = Form(None),
+    opening_hours: Optional[str] = Form(None),
+    description: Optional[str] = Form(None),
+    photo: Optional[UploadFile] = File(None),
+    photos: Optional[List[UploadFile]] = File(None),
+    latitude: Optional[float] = Form(None),
+    longitude: Optional[float] = Form(None),
+    current_user: dict = Depends(get_current_user)
+):
+    """Update the current logged-in clinic's profile details"""
+    if current_user["role"] != "clinic":
+        raise HTTPException(status_code=403, detail="Access denied. Clinic role required.")
+
+    updates = {}
+    if clinic_name is not None:
+        updates["clinic_name"] = clinic_name
+    if phone is not None:
+        updates["phone"] = phone
+    if address is not None:
+        updates["address"] = address
+    if city is not None:
+        updates["city"] = city
+    if state is not None:
+        updates["state"] = state
+    if zip_code is not None:
+        updates["zip_code"] = zip_code
+    if country is not None:
+        updates["country"] = country
+    if website is not None:
+        updates["website"] = website
+    if opening_hours is not None:
+        updates["opening_hours"] = opening_hours
+    if description is not None:
+        updates["description"] = description
+    if latitude is not None:
+        updates["latitude"] = latitude
+    if longitude is not None:
+        updates["longitude"] = longitude
+
+    # Upload main photo
+    if photo and photo.filename:
+        if not photo.content_type or not photo.content_type.startswith("image/"):
+            raise HTTPException(status_code=400, detail="Clinic photo must be an image")
+        
+        photo_bytes = await photo.read()
+        photo_ext = os.path.splitext(photo.filename)[1] or ".jpg"
+        photo_name = f"{clinic_name or 'logo'}-{int(time.time())}{photo_ext}"
+        photo_path = SupabaseStorage.upload_clinic_image(
+            user_id=current_user["id"],
+            file_data=photo_bytes,
+            filename=photo_name,
+            content_type=photo.content_type or "image/jpeg"
+        )
+        updates["clinic_logo_url"] = supabase.storage.from_("clinic-images").get_public_url(photo_path)
+
+    # Upload gallery photos
+    for gallery_photo in photos or []:
+        if not gallery_photo or not gallery_photo.filename:
+            continue
+        if not gallery_photo.content_type or not gallery_photo.content_type.startswith("image/"):
+            raise HTTPException(status_code=400, detail="Clinic gallery images must be images")
+
+        image_bytes = await gallery_photo.read()
+        image_ext = os.path.splitext(gallery_photo.filename)[1] or ".jpg"
+        image_name = f"gallery-{int(time.time())}-{gallery_photo.filename.replace(' ', '_')}"
+        if not image_name.endswith(image_ext):
+            image_name += image_ext
+        
+        # We upload it but we don't save to the main table, as SupabaseStorage lists them
+        SupabaseStorage.upload_clinic_image(
+            user_id=current_user["id"],
+            file_data=image_bytes,
+            filename=image_name,
+            content_type=gallery_photo.content_type or "image/jpeg",
+        )
+
+    result = ClinicService.update_clinic_profile(user_id=current_user["id"], updates=updates)
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+        
+    return result
+
+@router.get("/clinics")
+async def get_public_clinics():
+    """Public endpoint: Get all verified clinics"""
+    result = ClinicService.get_public_clinics()
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+    return result
+
+@router.get("/clinics/{clinic_id}")
+async def get_clinic_by_id(clinic_id: str):
+    """Public endpoint: Get clinic details by clinic ID"""
+    result = ClinicService.get_clinic_by_id(clinic_id=clinic_id)
+    if not result["success"]:
+        raise HTTPException(status_code=404, detail=result.get("error"))
+    return result
+
+@router.get("/clinic/patients")
+async def get_clinic_patients(current_user: dict = Depends(get_current_user)):
+    """Get all appointments / patients for the current clinic"""
+    if current_user["role"] != "clinic":
+        raise HTTPException(status_code=403, detail="Access denied. Clinic role required.")
+
+    # Get the clinic's ID from user_id
+    clinic_resp = supabase.table("clinics").select("id").eq("user_id", current_user["id"]).execute()
+    if not clinic_resp.data:
+        raise HTTPException(status_code=404, detail="Clinic profile not found")
+
+    clinic_id = clinic_resp.data[0]["id"]
+    
+    try:
+        resp = supabase.table("appointments").select("*").eq("clinic_id", clinic_id).order("appointment_date", desc=False).execute()
+        appts = resp.data or []
+
+        # Enrich each appointment with pet name and owner full name
+        enriched = []
+        for a in appts:
+            pet_name = None
+            owner_name = None
+            try:
+                if a.get("pet_id"):
+                    pet_resp = supabase.table("pets").select("name").eq("id", a.get("pet_id")).execute()
+                    if pet_resp.data:
+                        pet_name = pet_resp.data[0].get("name")
+                if a.get("owner_id"):
+                    owner_resp = supabase.table("pet_owners").select("full_name").eq("user_id", a.get("owner_id")).execute()
+                    if owner_resp.data:
+                        owner_name = owner_resp.data[0].get("full_name")
+            except Exception:
+                pass
+
+            item = dict(a)
+            item["pet_name"] = pet_name or a.get("pet_id")
+            item["owner_name"] = owner_name or a.get("owner_id")
+            enriched.append(item)
+
+        return {"success": True, "appointments": enriched, "count": len(enriched)}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

backend/routers/pets.py

@@ -0,0 +1,463 @@
+from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, File, Form
+from typing import Optional, List
+import logging
+import time
+import os
+import tempfile
+from backend.core.dependencies import get_current_user
+from backend.services.pet_service import PetService
+from chatbot.supabase_config import supabase, SupabaseStorage
+from chatbot.vaccine_service import VaccineService
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["Pets, Vaccines & Medical Records"])
+
+# ============================================
+# Pet Endpoints
+# ============================================
+
+@router.post("/pets")
+async def create_pet(
+    name: str = Form(...),
+    pet_type: str = Form(...),
+    breed: str = Form(...),
+    date_of_birth: str = Form(...),
+    weight: float = Form(...),
+    weight_unit: str = Form("kg"),
+    gender: Optional[str] = Form(None),
+    blood_type: Optional[str] = Form(None),
+    allergies: Optional[str] = Form(None),
+    medical_conditions: Optional[str] = Form(None),
+    notes: Optional[str] = Form(None),
+    photo: Optional[UploadFile] = File(None),
+    current_user: dict = Depends(get_current_user)
+):
+    """Add a new pet (Owner only)"""
+    if current_user["role"] != "owner":
+        raise HTTPException(status_code=403, detail="Only pet owners can add pets")
+
+    profile_image_url = None
+    if photo and photo.filename:
+        if not photo.content_type or not photo.content_type.startswith("image/"):
+            raise HTTPException(status_code=400, detail="Pet photo must be an image")
+
+        file_data = await photo.read()
+        file_ext = os.path.splitext(photo.filename)[1] or ".jpg"
+        storage_path = f"{current_user['id']}/{int(time.time())}-{name.replace(' ', '_')}{file_ext}"
+        SupabaseStorage.ensure_bucket("pet-images", public=True, allowed_mime_types=["image/*"])
+        supabase.storage.from_("pet-images").upload(
+            file=file_data,
+            path=storage_path,
+            file_options={
+                "content-type": photo.content_type or "image/jpeg",
+                "upsert": "false",
+            },
+        )
+        profile_image_url = supabase.storage.from_("pet-images").get_public_url(storage_path)
+
+    result = PetService.add_pet(
+        user_id=current_user["id"],
+        name=name,
+        pet_type=pet_type,
+        breed=breed,
+        date_of_birth=date_of_birth,
+        weight=weight,
+        weight_unit=weight_unit,
+        gender=gender,
+        blood_type=blood_type,
+        allergies=allergies,
+        medical_conditions=medical_conditions,
+        notes=notes,
+        profile_image_url=profile_image_url
+    )
+
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+
+    return result
+
+@router.get("/pets")
+async def get_pets(current_user: dict = Depends(get_current_user)):
+    """Get all pets for the currently logged-in user (Owner) or all pets if Clinic/Admin"""
+    if current_user["role"] == "owner":
+        result = PetService.get_user_pets(user_id=current_user["id"])
+    else:
+        try:
+            response = supabase.table("pets").select("*").execute()
+            result = {
+                "success": True,
+                "pets": response.data or [],
+                "count": len(response.data or [])
+            }
+        except Exception as e:
+            raise HTTPException(status_code=400, detail=str(e))
+
+    if not result["success"]:
+        raise HTTPException(status_code=400, detail=result.get("error"))
+
+    return result
+
+@router.get("/pets/{pet_id}")
+async def get_pet_detail(pet_id: str, current_user: dict = Depends(get_current_user)):
+    """Get detailed profile of a specific pet"""
+    try:
+        response = supabase.table("pets").select("*").eq("id", pet_id).execute()
+        if not response.data:
+            raise HTTPException(status_code=404, detail="Pet not found")
+        
+        pet = response.data[0]
+        if current_user["role"] == "owner" and pet["user_id"] != current_user["id"]:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+        return {"success": True, "pet": pet}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.put("/pets/{pet_id}")
+async def update_pet_detail(
+    pet_id: str,
+    name: Optional[str] = Form(None),
+    pet_type: Optional[str] = Form(None),
+    breed: Optional[str] = Form(None),
+    date_of_birth: Optional[str] = Form(None),
+    weight: Optional[float] = Form(None),
+    weight_unit: Optional[str] = Form(None),
+    gender: Optional[str] = Form(None),
+    blood_type: Optional[str] = Form(None),
+    allergies: Optional[str] = Form(None),
+    medical_conditions: Optional[str] = Form(None),
+    notes: Optional[str] = Form(None),
+    photo: Optional[UploadFile] = File(None),
+    current_user: dict = Depends(get_current_user)
+):
+    """Update details of a specific pet"""
+    try:
+        current = supabase.table("pets").select("*").eq("id", pet_id).execute()
+        if not current.data:
+            raise HTTPException(status_code=404, detail="Pet not found")
+        
+        pet = current.data[0]
+        if current_user["role"] == "owner" and pet["user_id"] != current_user["id"]:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+        updates = {}
+        if name is not None:
+            updates["name"] = name
+        if pet_type is not None:
+            updates["type"] = pet_type.lower()
+        if breed is not None:
+            updates["breed"] = breed
+        if date_of_birth is not None:
+            updates["date_of_birth"] = date_of_birth
+        if weight is not None:
+            updates["weight"] = weight
+        if weight_unit is not None:
+            updates["weight_unit"] = weight_unit
+        if gender is not None:
+            updates["gender"] = gender
+        if blood_type is not None:
+            updates["blood_type"] = blood_type
+        if allergies is not None:
+            updates["allergies"] = allergies
+        if medical_conditions is not None:
+            updates["medical_conditions"] = medical_conditions
+        if notes is not None:
+            updates["notes"] = notes
+
+        if photo and photo.filename:
+            if not photo.content_type or not photo.content_type.startswith("image/"):
+                raise HTTPException(status_code=400, detail="Pet photo must be an image")
+            
+            file_data = await photo.read()
+            file_ext = os.path.splitext(photo.filename)[1] or ".jpg"
+            storage_path = f"{pet['user_id']}/{int(time.time())}-{name or pet['name']}{file_ext}".replace(' ', '_')
+            SupabaseStorage.ensure_bucket("pet-images", public=True, allowed_mime_types=["image/*"])
+            supabase.storage.from_("pet-images").upload(
+                file=file_data,
+                path=storage_path,
+                file_options={
+                    "content-type": photo.content_type or "image/jpeg",
+                    "upsert": "false",
+                },
+            )
+            updates["profile_image_url"] = supabase.storage.from_("pet-images").get_public_url(storage_path)
+
+        result = PetService.update_pet(pet_id=pet_id, updates=updates)
+        if not result["success"]:
+            raise HTTPException(status_code=400, detail=result.get("error"))
+
+        return result
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ============================================
+# Vaccine Records Endpoints
+# ============================================
+
+@router.post("/vaccine-records")
+async def upload_vaccine_record(
+    pet_id: str = Form(...),
+    file: UploadFile = File(...),
+    upload_date: Optional[str] = Form(None),
+    current_user: dict = Depends(get_current_user)
+):
+    """Upload a vaccination record for a pet"""
+    try:
+        pet_resp = supabase.table("pets").select("user_id").eq("id", pet_id).execute()
+        if not pet_resp.data:
+            raise HTTPException(status_code=404, detail="Pet not found")
+        
+        if current_user["role"] == "owner" and pet_resp.data[0]["user_id"] != current_user["id"]:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+        file_data = await file.read()
+        file_type = "pdf" if file.content_type == "application/pdf" else "image"
+
+        result = PetService.upload_vaccine_record(
+            pet_id=pet_id,
+            file_data=file_data,
+            file_name=file.filename,
+            file_type=file_type,
+            uploaded_by=current_user["id"],
+            upload_date=upload_date
+        )
+
+        if not result["success"]:
+            raise HTTPException(status_code=400, detail=result.get("error"))
+
+        return result
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.get("/vaccine-records")
+async def get_vaccine_records(pet_id: str, current_user: dict = Depends(get_current_user)):
+    """Get all vaccine records for a pet"""
+    try:
+        pet_resp = supabase.table("pets").select("user_id").eq("id", pet_id).execute()
+        if not pet_resp.data:
+            raise HTTPException(status_code=404, detail="Pet not found")
+        
+        if current_user["role"] == "owner" and pet_resp.data[0]["user_id"] != current_user["id"]:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+        result = PetService.get_pet_vaccine_records(pet_id=pet_id)
+        if not result["success"]:
+            raise HTTPException(status_code=400, detail=result.get("error"))
+
+        return result
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+# ============================================
+# Advanced Vaccine Processing Endpoints
+# ============================================
+
+@router.post("/vaccines/upload-document")
+async def upload_vaccine_document(
+    pet_id: str = Form(...),
+    file: UploadFile = File(...),
+    current_user: dict = Depends(get_current_user)
+):
+    """Upload vaccine booklet/card image, extract data via VLM, and store records"""
+    logger.info(f"Uploading vaccine document for pet: {pet_id} by user: {current_user['id']}")
+    
+    # Check authorization
+    pet_resp = supabase.table("pets").select("user_id").eq("id", pet_id).execute()
+    if not pet_resp.data:
+        raise HTTPException(status_code=404, detail="Pet not found")
+    if current_user["role"] == "owner" and pet_resp.data[0]["user_id"] != current_user["id"]:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename or ".jpg")[1]) as tmp:
+        content = await file.read()
+        tmp.write(content)
+        tmp_path = tmp.name
+    
+    try:
+        file_ext = os.path.splitext(file.filename or ".jpg")[1]
+        storage_path = f"vaccine-documents/{pet_id}/{int(time.time())}{file_ext}"
+        
+        SupabaseStorage.ensure_bucket("vaccine-documents", public=True, allowed_mime_types=["image/*", "application/pdf"])
+        
+        with open(tmp_path, "rb") as f:
+            file_data = f.read()
+        
+        supabase.storage.from_("vaccine-documents").upload(
+            file=file_data,
+            path=storage_path,
+            file_options={
+                "content-type": file.content_type or "image/jpeg",
+                "upsert": "false",
+            },
+        )
+        image_url = supabase.storage.from_("vaccine-documents").get_public_url(storage_path)
+        
+        result = VaccineService.upload_vaccine_document(
+            pet_id=pet_id,
+            image_url=image_url,
+            image_path=tmp_path
+        )
+        
+        if not result.get("success"):
+            raise HTTPException(status_code=400, detail=result.get("error", "Failed to process vaccine document"))
+        
+        return {
+            "success": True,
+            "document_id": result.get("document_id"),
+            "records_count": result.get("records_count"),
+            "records": result.get("records"),
+            "message": f"Successfully extracted {result.get('records_count')} vaccine records!"
+        }
+    finally:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)
+
+@router.post("/vaccines/manual-entry")
+async def add_manual_vaccine(
+    pet_id: str = Form(...),
+    vaccine_name: str = Form(...),
+    vaccination_date: str = Form(...),
+    next_due_date: Optional[str] = Form(None),
+    batch_number: Optional[str] = Form(None),
+    veterinarian_name: Optional[str] = Form(None),
+    clinic_name: Optional[str] = Form(None),
+    clinic_id: Optional[str] = Form(None),
+    notes: Optional[str] = Form(None),
+    source: str = Form("vet_entry"),
+    current_user: dict = Depends(get_current_user)
+):
+    """Add a vaccine record manually (Clinics or Vets)"""
+    # Verify clinic role or admin
+    if current_user["role"] not in ["clinic", "admin"]:
+        raise HTTPException(status_code=403, detail="Only clinics and admins can make manual vaccine entries")
+
+    result = VaccineService.add_manual_vaccine_entry(
+        pet_id=pet_id,
+        vaccine_name=vaccine_name,
+        vaccination_date=vaccination_date,
+        next_due_date=next_due_date,
+        batch_number=batch_number,
+        veterinarian_name=veterinarian_name,
+        clinic_name=clinic_name,
+        clinic_id=clinic_id,
+        notes=notes,
+        source=source
+    )
+    
+    if not result.get("success"):
+        raise HTTPException(status_code=400, detail=result.get("error"))
+    
+    return result
+
+@router.get("/vaccines/{pet_id}")
+async def get_pet_vaccines(pet_id: str, current_user: dict = Depends(get_current_user)):
+    """Get all vaccination records for a pet"""
+    pet_resp = supabase.table("pets").select("user_id").eq("id", pet_id).execute()
+    if not pet_resp.data:
+        raise HTTPException(status_code=404, detail="Pet not found")
+    if current_user["role"] == "owner" and pet_resp.data[0]["user_id"] != current_user["id"]:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    result = VaccineService.get_pet_vaccines(pet_id=pet_id)
+    if not result.get("success"):
+        raise HTTPException(status_code=400, detail=result.get("error"))
+    
+    return result
+
+@router.get("/vaccines/{pet_id}/documents")
+async def get_pet_vaccine_documents(pet_id: str, current_user: dict = Depends(get_current_user)):
+    """Get uploaded vaccine documents for a pet"""
+    pet_resp = supabase.table("pets").select("user_id").eq("id", pet_id).execute()
+    if not pet_resp.data:
+        raise HTTPException(status_code=404, detail="Pet not found")
+    if current_user["role"] == "owner" and pet_resp.data[0]["user_id"] != current_user["id"]:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    result = VaccineService.get_pet_vaccine_documents(pet_id=pet_id)
+    if not result.get("success"):
+        raise HTTPException(status_code=400, detail=result.get("error"))
+    
+    return result
+
+@router.post("/vaccines/check-reminders")
+async def check_vaccine_reminders(current_user: dict = Depends(get_current_user)):
+    """Trigger reminder check for all vaccines (Admin only)"""
+    if current_user["role"] != "admin":
+        raise HTTPException(status_code=403, detail="Admin access required")
+        
+    result = VaccineService.check_and_send_reminders()
+    return result
+
+# ============================================
+# Medical Records Endpoints
+# ============================================
+
+@router.post("/medical-records")
+async def create_medical_record(
+    clinic_id: str,
+    pet_id: str,
+    record_type: str,
+    visit_date: str,
+    diagnosis: Optional[str] = None,
+    treatment: Optional[str] = None,
+    notes: Optional[str] = None,
+    current_user: dict = Depends(get_current_user)
+):
+    """Create medical record (Clinics only)"""
+    if current_user["role"] != "clinic":
+        raise HTTPException(status_code=403, detail="Only clinics can create medical records")
+
+    # Check if the clinic owns this clinic_id
+    clinic_resp = supabase.table("clinics").select("id").eq("user_id", current_user["id"]).execute()
+    if not clinic_resp.data or clinic_resp.data[0]["id"] != clinic_id:
+        raise HTTPException(status_code=403, detail="Access denied. Invalid clinic identity.")
+
+    try:
+        medical_data = {
+            "pet_id": pet_id,
+            "clinic_id": clinic_id,
+            "record_type": record_type,
+            "visit_date": visit_date,
+            "diagnosis": diagnosis,
+            "treatment": treatment,
+            "notes": notes
+        }
+        response = supabase.table("medical_records").insert(medical_data).execute()
+        if not response.data:
+            raise HTTPException(status_code=400, detail="Failed to create medical record")
+
+        return {
+            "success": True,
+            "record_id": response.data[0]["id"],
+            "message": "Medical record created successfully!"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@router.get("/pet/medical-records")
+async def get_pet_medical_records(pet_id: str, current_user: dict = Depends(get_current_user)):
+    """Get all medical records for a pet"""
+    pet_resp = supabase.table("pets").select("user_id").eq("id", pet_id).execute()
+    if not pet_resp.data:
+        raise HTTPException(status_code=404, detail="Pet not found")
+    if current_user["role"] == "owner" and pet_resp.data[0]["user_id"] != current_user["id"]:
+        raise HTTPException(status_code=403, detail="Access denied")
+
+    try:
+        response = supabase.table("medical_records").select("*").eq("pet_id", pet_id).execute()
+        return {
+            "success": True,
+            "records": response.data or [],
+            "count": len(response.data or [])
+        }
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))

backend/schemas/schemas.py

@@ -0,0 +1,56 @@
+from pydantic import BaseModel
+from typing import Optional, List
+
+class RegisterOwnerRequest(BaseModel):
+    first_name: str
+    last_name: str
+    phone: str
+    address: Optional[str] = None
+    state: Optional[str] = None
+    zip_code: Optional[str] = None
+    country: Optional[str] = None
+    bio: Optional[str] = None
+
+class RegisterClinicRequest(BaseModel):
+    clinic_name: str
+    phone: str
+    address: str
+    city: Optional[str] = None
+    state: Optional[str] = None
+    zip_code: Optional[str] = None
+    country: Optional[str] = None
+    website: Optional[str] = None
+    opening_hours: Optional[str] = None
+    description: Optional[str] = None
+    clinic_logo_url: Optional[str] = None
+    license_document_url: Optional[str] = None
+
+class NotificationReadRequest(BaseModel):
+    user_id: str
+
+class AddPetRequest(BaseModel):
+    name: str
+    pet_type: str
+    breed: str
+    date_of_birth: str
+    weight: float
+    weight_unit: Optional[str] = "kg"
+    gender: Optional[str] = None
+    blood_type: Optional[str] = None
+    allergies: Optional[str] = None
+    medical_conditions: Optional[str] = None
+    notes: Optional[str] = None
+
+class CreateAppointmentRequest(BaseModel):
+    pet_id: str
+    clinic_id: str
+    appointment_date: str
+    appointment_time: str
+    reason: Optional[str] = None
+    notes: Optional[str] = None
+
+class CreateReviewRequest(BaseModel):
+    appointment_id: str
+    rating: int
+    treatment: str
+    comment: Optional[str] = None

backend/services/appointment_service.py

@@ -0,0 +1,289 @@
+from typing import Dict, List, Optional
+from datetime import datetime
+import time
+import logging
+from chatbot.supabase_config import supabase
+
+logger = logging.getLogger(__name__)
+
+class AppointmentService:
+    """Service for managing appointments and reviews"""
+
+    @staticmethod
+    def create_appointment(
+        pet_id: str,
+        clinic_id: str,
+        owner_id: str,
+        appointment_date: str,
+        appointment_time: str,
+        reason: Optional[str] = None,
+        notes: Optional[str] = None,
+    ) -> Dict:
+        """Create appointment"""
+        try:
+            appointment_data = {
+                "pet_id": pet_id,
+                "clinic_id": clinic_id,
+                "owner_id": owner_id,
+                "appointment_date": appointment_date,
+                "appointment_time": appointment_time,
+                "reason": reason,
+                "notes": notes,
+                "status": "scheduled"
+            }
+            
+            response = supabase.table("appointments").insert(appointment_data).execute()
+            if not response.data:
+                return {"success": False, "error": "Failed to create appointment"}
+
+            created = response.data[0]
+            
+            # Send notifications
+            try:
+                AppointmentService._send_appointment_notifications(created)
+            except Exception as notif_err:
+                logger.warning(f"Failed to send appointment notifications: {notif_err}")
+
+            return {
+                "success": True,
+                "appointment_id": created["id"],
+                "appointment": created,
+                "message": "Appointment created successfully!"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error creating appointment: {str(e)}"
+            }
+
+    @staticmethod
+    def get_owner_appointments(owner_id: str) -> Dict:
+        """Get all appointments for pet owner"""
+        try:
+            response = supabase.table("appointments").select("*").eq("owner_id", owner_id).execute()
+            appointments = response.data or []
+            # We can enrich reviews here if needed
+            return {
+                "success": True,
+                "appointments": appointments,
+                "count": len(appointments)
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error fetching owner appointments: {str(e)}"
+            }
+
+    @staticmethod
+    def get_clinic_appointments(clinic_id: str) -> Dict:
+        """Get all appointments for clinic"""
+        try:
+            response = supabase.table("appointments").select("*").eq("clinic_id", clinic_id).execute()
+            appointments = response.data or []
+            return {
+                "success": True,
+                "appointments": appointments,
+                "count": len(appointments)
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error fetching clinic appointments: {str(e)}"
+            }
+
+    @staticmethod
+    def get_pet_appointments(pet_id: str) -> Dict:
+        """Get all appointments for a pet"""
+        try:
+            response = supabase.table("appointments").select("*").eq("pet_id", pet_id).execute()
+            appointments = response.data or []
+            return {
+                "success": True,
+                "appointments": appointments,
+                "count": len(appointments)
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error fetching pet appointments: {str(e)}"
+            }
+
+    @staticmethod
+    def update_appointment_status(appointment_id: str, status: str) -> Dict:
+        """Update appointment status (scheduled, completed, cancelled, etc.)"""
+        try:
+            # Fetch appointment
+            appt_resp = supabase.table("appointments").select("*").eq("id", appointment_id).execute()
+            if not appt_resp.data:
+                return {"success": False, "error": "Appointment not found"}
+            
+            appt = appt_resp.data[0]
+            
+            # Update status
+            timestamp = datetime.utcnow().isoformat()
+            supabase.table("appointments").update({"status": status, "updated_at": timestamp}).eq("id", appointment_id).execute()
+            
+            # Send status update notifications
+            try:
+                AppointmentService._send_status_notifications(appt, status)
+            except Exception as notif_err:
+                logger.warning(f"Failed to send status notifications: {notif_err}")
+
+            return {
+                "success": True,
+                "appointment_id": appointment_id,
+                "status": status
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error updating appointment status: {str(e)}"
+            }
+
+    @staticmethod
+    def create_review(
+        appointment_id: str,
+        rating: int,
+        treatment: str,
+        comment: Optional[str] = None,
+    ) -> Dict:
+        """Create review for a completed appointment"""
+        try:
+            # Fetch appointment
+            appt_resp = supabase.table("appointments").select("*").eq("id", appointment_id).execute()
+            if not appt_resp.data:
+                return {"success": False, "error": "Appointment not found"}
+            
+            appt = appt_resp.data[0]
+            if appt.get("status") != "completed":
+                return {"success": False, "error": "Only completed appointments can be reviewed"}
+
+            review_data = {
+                "appointment_id": appointment_id,
+                "clinic_id": appt.get("clinic_id"),
+                "pet_id": appt.get("pet_id"),
+                "owner_id": appt.get("owner_id"),
+                "rating": rating,
+                "treatment": treatment[:100],
+                "comment": comment,
+            }
+
+            response = supabase.table("clinic_reviews").insert(review_data).execute()
+            if not response.data:
+                return {"success": False, "error": "Failed to create review"}
+
+            created_review = response.data[0]
+
+            # Notify clinic
+            try:
+                AppointmentService._notify_clinic_about_review(created_review)
+            except Exception as notif_err:
+                logger.warning(f"Failed to notify clinic about review: {notif_err}")
+
+            return {
+                "success": True,
+                "review": created_review,
+                "message": "Review submitted successfully"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error creating review: {str(e)}"
+            }
+
+    @staticmethod
+    def get_reviews_for_clinic(clinic_id: str) -> Dict:
+        """Get reviews for a clinic"""
+        try:
+            response = supabase.table("clinic_reviews").select("*").eq("clinic_id", clinic_id).order("created_at", desc=True).execute()
+            reviews = response.data or []
+            avg_rating = round(sum(r.get("rating", 0) for r in reviews) / len(reviews), 1) if reviews else 0.0
+            return {
+                "success": True,
+                "reviews": reviews,
+                "count": len(reviews),
+                "average_rating": avg_rating
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error fetching clinic reviews: {str(e)}"
+            }
+
+    # Private helper methods for notifications
+    @staticmethod
+    def _create_notification(user_id: str, type_: str, title: str, message: str, role: str, entity_type: str, entity_id: str):
+        payload = {
+            "user_id": user_id,
+            "user_role": role,
+            "type": type_,
+            "title": title,
+            "message": message,
+            "entity_type": entity_type,
+            "entity_id": entity_id,
+            "is_read": False,
+            "created_at": datetime.utcnow().isoformat(),
+        }
+        supabase.table("notifications").insert(payload).execute()
+
+    @staticmethod
+    def _send_appointment_notifications(appt: Dict):
+        pet_resp = supabase.table("pets").select("name").eq("id", appt["pet_id"]).execute()
+        pet_name = pet_resp.data[0]["name"] if pet_resp.data else "your pet"
+        
+        clinic_resp = supabase.table("clinics").select("clinic_name", "user_id").eq("id", appt["clinic_id"]).execute()
+        clinic_name = "Clinic"
+        clinic_user_id = None
+        if clinic_resp.data:
+            clinic_name = clinic_resp.data[0]["clinic_name"]
+            clinic_user_id = clinic_resp.data[0]["user_id"]
+
+        title = "Appointment Scheduled"
+        message = f"{pet_name} has a new appointment with {clinic_name} on {appt['appointment_date']} at {appt['appointment_time']}."
+        
+        # Notify owner
+        AppointmentService._create_notification(appt["owner_id"], "appointment", title, message, "owner", "appointment", appt["id"])
+        
+        # Notify clinic
+        if clinic_user_id:
+            AppointmentService._create_notification(clinic_user_id, "appointment", title, message, "clinic", "appointment", appt["id"])
+
+    @staticmethod
+    def _send_status_notifications(appt: Dict, status: str):
+        pet_resp = supabase.table("pets").select("name").eq("id", appt["pet_id"]).execute()
+        pet_name = pet_resp.data[0]["name"] if pet_resp.data else "your pet"
+        
+        clinic_resp = supabase.table("clinics").select("clinic_name", "user_id").eq("id", appt["clinic_id"]).execute()
+        clinic_name = "Clinic"
+        clinic_user_id = None
+        if clinic_resp.data:
+            clinic_name = clinic_resp.data[0]["clinic_name"]
+            clinic_user_id = clinic_resp.data[0]["user_id"]
+
+        status_label = status.replace("_", " ").title()
+        title = f"Appointment {status_label}"
+        message = f"{pet_name}'s appointment with {clinic_name} on {appt['appointment_date']} at {appt['appointment_time']} was updated to {status_label}."
+        
+        # Notify owner
+        AppointmentService._create_notification(appt["owner_id"], "appointment_status", title, message, "owner", "appointment", appt["id"])
+        
+        # Notify clinic
+        if clinic_user_id:
+            AppointmentService._create_notification(clinic_user_id, "appointment_status", title, message, "clinic", "appointment", appt["id"])
+
+    @staticmethod
+    def _notify_clinic_about_review(review: Dict):
+        clinic_resp = supabase.table("clinics").select("user_id", "clinic_name").eq("id", review["clinic_id"]).execute()
+        if clinic_resp.data and clinic_resp.data[0].get("user_id"):
+            clinic_user_id = clinic_resp.data[0]["user_id"]
+            clinic_name = clinic_resp.data[0]["clinic_name"]
+            AppointmentService._create_notification(
+                clinic_user_id,
+                "clinic_review",
+                "New Client Review",
+                f"A pet owner left a {review['rating']}-star review for {clinic_name}.",
+                "clinic",
+                "review",
+                review["id"]
+            )
+        

backend/services/auth_service.py

@@ -0,0 +1,203 @@
+from typing import Dict, Optional
+from chatbot.supabase_config import supabase
+
+class AuthService:
+    """Authentication and Profile Service"""
+
+    @staticmethod
+    def register_pet_owner(
+        user_id: str,
+        email: str,
+        first_name: str,
+        last_name: str,
+        phone: str,
+        address: Optional[str] = None,
+        state: Optional[str] = None,
+        zip_code: Optional[str] = None,
+        country: Optional[str] = None,
+        bio: Optional[str] = None,
+    ) -> Dict:
+        """Complete pet owner profile registration"""
+        try:
+            # 1. Update phone and role in users
+            supabase.table("users").update({"phone_number": phone, "role": "owner"}).eq("id", user_id).execute()
+
+            # 2. Insert or update pet_owners (idempotent registration)
+            owner_data = {
+                "user_id": user_id,
+                "full_name": f"{first_name} {last_name}",
+                "email": email,
+                "phone": phone,
+                "address": address,
+                "state": state,
+                "zip_code": zip_code,
+                "country": country,
+                "bio": bio,
+            }
+
+            existing = supabase.table("pet_owners").select("*").eq("user_id", user_id).execute()
+            if existing.data:
+                response = supabase.table("pet_owners").update(owner_data).eq("user_id", user_id).execute()
+            else:
+                response = supabase.table("pet_owners").insert(owner_data).execute()
+            
+            return {
+                "success": True,
+                "user_id": user_id,
+                "role": "owner",
+                "profile": response.data[0] if response.data else {},
+                "message": "Pet owner profile registered successfully!"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Registration failed: {str(e)}"
+            }
+
+    @staticmethod
+    def register_clinic(
+        user_id: str,
+        email: str,
+        clinic_name: str,
+        phone: str,
+        address: str,
+        city: Optional[str] = None,
+        state: Optional[str] = None,
+        zip_code: Optional[str] = None,
+        country: Optional[str] = None,
+        website: Optional[str] = None,
+        opening_hours: Optional[str] = None,
+        description: Optional[str] = None,
+        clinic_logo_url: Optional[str] = None,
+        license_document_url: Optional[str] = None,
+        latitude: Optional[float] = None,
+        longitude: Optional[float] = None,
+    ) -> Dict:
+        """Complete clinic profile registration"""
+        try:
+            # 1. Update phone and role in users
+            supabase.table("users").update({"phone_number": phone, "role": "clinic"}).eq("id", user_id).execute()
+
+            # 2. Insert or update clinics (idempotent registration)
+            clinic_data = {
+                "user_id": user_id,
+                "clinic_name": clinic_name,
+                "email": email,
+                "phone": phone,
+                "address": address,
+                "city": city,
+                "state": state,
+                "zip_code": zip_code,
+                "country": country,
+                "website": website,
+                "opening_hours": opening_hours,
+                "description": description,
+                "clinic_logo_url": clinic_logo_url,
+                "license_document_url": license_document_url,
+                "latitude": latitude,
+                "longitude": longitude,
+            }
+
+            existing = supabase.table("clinics").select("*").eq("user_id", user_id).execute()
+            if existing.data:
+                # Preserve existing verification status
+                clinic_data["is_verified"] = existing.data[0].get("is_verified", False)
+                response = supabase.table("clinics").update(clinic_data).eq("user_id", user_id).execute()
+            else:
+                clinic_data["is_verified"] = False  # Starts as pending
+                response = supabase.table("clinics").insert(clinic_data).execute()
+            
+            return {
+                "success": True,
+                "user_id": user_id,
+                "role": "clinic",
+                "profile": response.data[0] if response.data else {},
+                "message": "Clinic profile registered successfully! Pending admin approval."
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Clinic registration failed: {str(e)}"
+            }
+
+    @staticmethod
+    def get_user_profile(user_id: str) -> Dict:
+        """Get user profile based on their role in the users table"""
+        try:
+            # Get profile
+            profile_response = supabase.table("users").select("*").eq("id", user_id).execute()
+            if not profile_response.data:
+                return {"success": False, "error": "User profile not found"}
+
+            profile = profile_response.data[0]
+            role = profile.get("role")
+
+            # Get detail profile based on role
+            if role == "owner":
+                detail_response = supabase.table("pet_owners").select("*").eq("user_id", user_id).execute()
+            elif role == "clinic":
+                detail_response = supabase.table("clinics").select("*").eq("user_id", user_id).execute()
+            else:
+                return {
+                    "success": True,
+                    "user_id": user_id,
+                    "role": role,
+                    "profile": {
+                        "id": user_id,
+                        "role": role,
+                        "email": "admin@petai.com" if role == "admin" else ""
+                    }
+                }
+
+            if not detail_response.data:
+                return {"success": False, "error": f"{role.title()} details not found"}
+
+            return {
+                "success": True,
+                "user_id": user_id,
+                "role": role,
+                "profile": detail_response.data[0]
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error fetching profile: {str(e)}"
+            }
+
+    @staticmethod
+    def update_user_profile(user_id: str, updates: Dict) -> Dict:
+        """Update pet owner user profile"""
+        try:
+            # Check role
+            profile_resp = supabase.table("users").select("role").eq("id", user_id).execute()
+            if not profile_resp.data or profile_resp.data[0].get("role") != "owner":
+                return {"success": False, "error": "Only pet owner profiles can be updated here"}
+
+            # Update pet_owners
+            if updates:
+                supabase.table("pet_owners").update(updates).eq("user_id", user_id).execute()
+                
+                # Also update the users table to keep them in sync
+                user_updates = {}
+                if "full_name" in updates:
+                    user_updates["full_name"] = updates["full_name"]
+                if "phone" in updates:
+                    user_updates["phone_number"] = updates["phone"]
+                if "profile_image_url" in updates:
+                    user_updates["avatar_url"] = updates["profile_image_url"]
+                
+                if user_updates:
+                    supabase.table("users").update(user_updates).eq("id", user_id).execute()
+                
+            # Retrieve updated profile
+            refreshed = supabase.table("pet_owners").select("*").eq("user_id", user_id).execute()
+            
+            return {
+                "success": True,
+                "profile": refreshed.data[0] if refreshed.data else {}
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error updating profile: {str(e)}"
+            }

backend/services/clinic_service.py

@@ -0,0 +1,250 @@
+from typing import Dict, List, Optional
+from datetime import datetime
+import logging
+from chatbot.supabase_config import supabase, SupabaseStorage
+
+logger = logging.getLogger(__name__)
+
+REJECTION_MARKER = "__ADMIN_REJECTION__::"
+
+class ClinicService:
+    """Service for managing clinic profiles, approvals, and public listings"""
+
+    @staticmethod
+    def get_clinic_profile(user_id: str) -> Dict:
+        """Get clinic profile by owner's user_id"""
+        try:
+            response = supabase.table("clinics").select("*").eq("user_id", user_id).execute()
+            if not response.data:
+                return {"success": False, "error": "Clinic not found"}
+
+            clinic = ClinicService._parse_clinic_status(response.data[0])
+            clinic["gallery_urls"] = SupabaseStorage.list_clinic_images(user_id)
+            
+            if not clinic.get("clinic_logo_url") and clinic["gallery_urls"]:
+                clinic["clinic_logo_url"] = clinic["gallery_urls"][0]
+
+            return {"success": True, "clinic": clinic}
+        except Exception as e:
+            return {"success": False, "error": f"Error fetching clinic: {str(e)}"}
+
+    @staticmethod
+    def update_clinic_profile(user_id: str, updates: Dict) -> Dict:
+        """Update clinic profile details"""
+        try:
+            if updates:
+                supabase.table("clinics").update(updates).eq("user_id", user_id).execute()
+
+            # Refresh and return
+            return ClinicService.get_clinic_profile(user_id)
+        except Exception as e:
+            return {"success": False, "error": f"Error updating clinic: {str(e)}"}
+
+    @staticmethod
+    def get_public_clinics() -> Dict:
+        """List verified clinics for the public frontend"""
+        try:
+            resp = supabase.table("clinics").select("*").eq("is_verified", True).order("created_at", desc=True).execute()
+            clinics = []
+            for clinic_data in (resp.data or []):
+                parsed = ClinicService._parse_clinic_status(clinic_data)
+                uid = parsed.get("user_id")
+                parsed["gallery_urls"] = SupabaseStorage.list_clinic_images(uid) if uid else []
+                if not parsed.get("clinic_logo_url") and parsed["gallery_urls"]:
+                    parsed["clinic_logo_url"] = parsed["gallery_urls"][0]
+                clinics.append(parsed)
+
+            return {"success": True, "clinics": clinics, "count": len(clinics)}
+        except Exception as e:
+            return {"success": False, "error": f"Error fetching public clinics: {str(e)}"}
+
+    @staticmethod
+    def get_clinic_by_id(clinic_id: str) -> Dict:
+        """Get public details of a clinic by its clinic ID"""
+        try:
+            resp = supabase.table("clinics").select("*").eq("id", clinic_id).execute()
+            if not resp.data:
+                return {"success": False, "error": "Clinic not found"}
+
+            clinic = ClinicService._parse_clinic_status(resp.data[0])
+            uid = clinic.get("user_id")
+            clinic["gallery_urls"] = SupabaseStorage.list_clinic_images(uid) if uid else []
+            if not clinic.get("clinic_logo_url") and clinic["gallery_urls"]:
+                clinic["clinic_logo_url"] = clinic["gallery_urls"][0]
+
+            return {"success": True, "clinic": clinic}
+        except Exception as e:
+            return {"success": False, "error": f"Error fetching clinic: {str(e)}"}
+
+    @staticmethod
+    def get_pending_clinics() -> Dict:
+        """List all pending clinics (unverified and not rejected)"""
+        try:
+            resp = supabase.table("clinics").select("*").eq("is_verified", False).execute()
+            pending = []
+            for clinic in (resp.data or []):
+                parsed = ClinicService._parse_clinic_status(clinic)
+                if parsed["verification_status"] == "pending":
+                    pending.append(parsed)
+            return {"success": True, "clinics": pending, "count": len(pending)}
+        except Exception as e:
+            return {"success": False, "error": f"Error fetching pending clinics: {str(e)}"}
+
+    @staticmethod
+    def approve_clinic(clinic_id: str) -> Dict:
+        """Approve clinic (admin action)"""
+        try:
+            clinic_resp = supabase.table("clinics").select("id", "user_id", "clinic_name").eq("id", clinic_id).execute()
+            if not clinic_resp.data:
+                return {"success": False, "error": "Clinic not found"}
+
+            clinic = clinic_resp.data[0]
+            user_id = clinic.get("user_id")
+            clinic_name = clinic.get("clinic_name") or "Your clinic"
+            
+            # Fetch current description and strip rejection marker if any
+            current = supabase.table("clinics").select("description").eq("id", clinic_id).execute()
+            current_desc = current.data[0].get("description") if current.data else ""
+            clean_desc = ClinicService._strip_rejection_marker(current_desc)
+
+            # Update clinic to verified
+            supabase.table("clinics").update({"is_verified": True, "description": clean_desc}).eq("id", clinic_id).execute()
+
+            # Enable corresponding profile (profile is already active via auth, no-op)
+            if user_id:
+                # Create notification
+                ClinicService._create_notification(
+                    user_id,
+                    "clinic_approval",
+                    "Clinic Approved ✅",
+                    f"Congratulations! {clinic_name} has been approved by the admin. You can now access all features.",
+                    "clinic",
+                    "clinic",
+                    clinic_id
+                )
+
+            return {"success": True, "clinic_id": clinic_id, "message": "Clinic approved successfully!"}
+        except Exception as e:
+            return {"success": False, "error": f"Error approving clinic: {str(e)}"}
+
+    @staticmethod
+    def reject_clinic(clinic_id: str, reason: Optional[str] = None) -> Dict:
+        """Reject clinic (admin action)"""
+        try:
+            clinic_resp = supabase.table("clinics").select("id", "user_id", "clinic_name").eq("id", clinic_id).execute()
+            if not clinic_resp.data:
+                return {"success": False, "error": "Clinic not found"}
+
+            clinic = clinic_resp.data[0]
+            user_id = clinic.get("user_id")
+            clinic_name = clinic.get("clinic_name") or "Your clinic"
+
+            # Fetch current description to append rejection marker
+            current = supabase.table("clinics").select("description").eq("id", clinic_id).execute()
+            current_desc = ""
+            if current.data:
+                current_desc = ClinicService._strip_rejection_marker(current.data[0].get("description") or "")
+
+            timestamp = datetime.utcnow().isoformat()
+            marker = REJECTION_MARKER
+            if reason:
+                safe_reason = str(reason).replace("::", "--")
+                marker_payload = f"reason={safe_reason}::time={timestamp}"
+                new_desc = current_desc + ("\n\n" if current_desc else "") + marker + marker_payload
+            else:
+                marker_payload = f"time={timestamp}"
+                new_desc = current_desc + ("\n\n" if current_desc else "") + marker + marker_payload
+
+            # Update clinic: set is_verified false and append description marker
+            supabase.table("clinics").update({"is_verified": False, "description": new_desc}).eq("id", clinic_id).execute()
+
+            # Keep associated auth profile active so they can log in, view status, and edit/resubmit profile
+            if user_id:
+                # Create notification
+                rejection_message = f"Your registration for {clinic_name} was rejected by the admin."
+                if reason:
+                    rejection_message += f" Reason: {reason}"
+                else:
+                    rejection_message += " Please check your documents and resubmit."
+                
+                ClinicService._create_notification(
+                    user_id,
+                    "clinic_rejection",
+                    "Clinic Verification Rejected ❌",
+                    rejection_message,
+                    "clinic",
+                    "clinic",
+                    clinic_id
+                )
+
+            return {
+                "success": True,
+                "clinic_id": clinic_id,
+                "message": "Clinic rejected successfully",
+                "reason": reason,
+                "rejected_at": timestamp
+            }
+        except Exception as e:
+            return {"success": False, "error": f"Error rejecting clinic: {str(e)}"}
+
+    # Private helper methods
+    @staticmethod
+    def _parse_clinic_status(clinic: dict) -> dict:
+        clinic_copy = dict(clinic)
+        desc = clinic_copy.get("description") or ""
+        is_rejected = False
+        rejection_reason = None
+        rejected_at = None
+
+        if REJECTION_MARKER in desc:
+            try:
+                marker_payload = desc.split(REJECTION_MARKER, 1)[1].split("::")
+                kv = {}
+                for part in marker_payload:
+                    if "=" in part:
+                        key, value = part.split("=", 1)
+                        kv[key] = value
+                rejection_reason = kv.get("reason")
+                rejected_at = kv.get("time")
+                is_rejected = True
+            except Exception:
+                is_rejected = False
+
+        if clinic_copy.get("is_verified"):
+            verification_status = "approved"
+            is_rejected = False
+            rejection_reason = None
+            rejected_at = None
+        elif is_rejected:
+            verification_status = "rejected"
+        else:
+            verification_status = "pending"
+
+        clinic_copy["is_rejected"] = is_rejected
+        clinic_copy["rejection_reason"] = rejection_reason
+        clinic_copy["rejected_at"] = rejected_at
+        clinic_copy["verification_status"] = verification_status
+        return clinic_copy
+
+    @staticmethod
+    def _strip_rejection_marker(description: Optional[str]) -> str:
+        if not description:
+            return ""
+        if REJECTION_MARKER not in description:
+            return description.strip()
+        return description.split(REJECTION_MARKER, 1)[0].rstrip()
+
+    @staticmethod
+    def _create_notification(user_id: str, type_: str, title: str, message: str, role: str, entity_type: str, entity_id: str):
+        payload = {
+            "user_id": user_id,
+            "user_role": role,
+            "type": type_,
+            "title": title,
+            "message": message,
+            "entity_type": entity_type,
+            "entity_id": entity_id,
+            "is_read": False,
+            "created_at": datetime.utcnow().isoformat(),
+        }
+        supabase.table("notifications").insert(payload).execute()

backend/services/pet_service.py

@@ -0,0 +1,165 @@
+from typing import Dict, Optional
+import time
+from chatbot.supabase_config import supabase, SupabaseStorage
+
+class PetService:
+    """Service for managing pets and their vaccine records"""
+
+    @staticmethod
+    def add_pet(
+        user_id: str,
+        name: str,
+        pet_type: str,
+        breed: str,
+        date_of_birth: str,
+        weight: float,
+        weight_unit: str = "kg",
+        gender: Optional[str] = None,
+        blood_type: Optional[str] = None,
+        allergies: Optional[str] = None,
+        medical_conditions: Optional[str] = None,
+        notes: Optional[str] = None,
+        profile_image_url: Optional[str] = None,
+    ) -> Dict:
+        """Add new pet"""
+        try:
+            pet_data = {
+                "user_id": user_id,
+                "name": name,
+                "type": pet_type,
+                "breed": breed,
+                "date_of_birth": date_of_birth,
+                "weight": weight,
+                "weight_unit": weight_unit,
+                "gender": gender,
+                "blood_type": blood_type,
+                "allergies": allergies,
+                "medical_conditions": medical_conditions,
+                "notes": notes,
+                "profile_image_url": profile_image_url,
+            }
+
+            response = supabase.table("pets").insert(pet_data).execute()
+            if not response.data:
+                return {"success": False, "error": "Failed to create pet"}
+
+            pet = response.data[0]
+            return {
+                "success": True,
+                "pet_id": pet["id"],
+                "pet_name": pet["name"],
+                "message": "Pet added successfully!"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error adding pet: {str(e)}"
+            }
+
+    @staticmethod
+    def get_user_pets(user_id: str) -> Dict:
+        """Get all pets for a user"""
+        try:
+            response = supabase.table("pets").select("*").eq("user_id", user_id).execute()
+            return {
+                "success": True,
+                "pets": response.data or [],
+                "count": len(response.data or [])
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error fetching pets: {str(e)}"
+            }
+
+    @staticmethod
+    def update_pet(pet_id: str, updates: Dict) -> Dict:
+        """Update pet details"""
+        try:
+            response = supabase.table("pets").update(updates).eq("id", pet_id).execute()
+            if not response.data:
+                return {
+                    "success": False,
+                    "error": "Pet not found or not updated"
+                }
+            return {
+                "success": True,
+                "pet": response.data[0],
+                "message": "Pet updated successfully!"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error updating pet: {str(e)}"
+            }
+
+    @staticmethod
+    def upload_vaccine_record(
+        pet_id: str,
+        file_data: bytes,
+        file_name: str,
+        file_type: str,
+        uploaded_by: str,
+        upload_date: Optional[str] = None,
+    ) -> Dict:
+        """Upload vaccine record file"""
+        try:
+            from datetime import datetime
+            if not upload_date:
+                upload_date = datetime.now().strftime("%Y-%m-%d")
+
+            file_path = f"vaccine-records/{pet_id}/{int(time.time())}-{file_name}"
+
+            # Upload to storage
+            SupabaseStorage.ensure_bucket("vaccine-documents", public=False)
+            supabase.storage.from_("vaccine-documents").upload(
+                file=file_data,
+                path=file_path,
+                file_options={
+                    "content-type": "application/pdf" if file_type == "pdf" else "image/jpeg",
+                    "upsert": "false",
+                },
+            )
+
+            # Save record to database
+            record_data = {
+                "pet_id": pet_id,
+                "file_name": file_name,
+                "file_url": file_path,
+                "file_type": file_type,
+                "file_size": len(file_data),
+                "upload_date": upload_date,
+                "uploaded_by": uploaded_by,
+            }
+
+            response = supabase.table("vaccine_records").insert(record_data).execute()
+            if not response.data:
+                return {"success": False, "error": "Failed to save vaccine record"}
+
+            return {
+                "success": True,
+                "record_id": response.data[0]["id"],
+                "file_url": file_path,
+                "message": "Vaccine record uploaded successfully!"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error uploading vaccine record: {str(e)}"
+            }
+
+    @staticmethod
+    def get_pet_vaccine_records(pet_id: str) -> Dict:
+        """Get all vaccine records for a pet"""
+        try:
+            response = supabase.table("vaccine_records").select("*").eq("pet_id", pet_id).execute()
+            return {
+                "success": True,
+                "records": response.data or [],
+                "count": len(response.data or [])
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Error fetching vaccine records: {str(e)}"
+            }

backend/services/predictor.py

@@ -0,0 +1,15 @@
+import torch
+from backend.core.config import DEVICE
+
+def predict(model, class_names, tensor):
+    tensor = tensor.to(DEVICE)
+
+    with torch.no_grad():
+        outputs = model(tensor)
+        probs = torch.nn.functional.softmax(outputs, dim=1)
+        conf, pred = torch.max(probs, 1)
+
+    return {
+        "class": class_names[pred.item()],
+        "confidence": float(conf.item())
+    }

backend/services/router.py

@@ -0,0 +1,13 @@
+def route_prediction(app, animal, disease_type, tensor):
+
+    if animal == "dog" and disease_type == "skin":
+        model, classes = app.state.dog_skin
+    elif animal == "dog" and disease_type == "eye":
+        model, classes = app.state.dog_eye
+    elif animal == "cat" and disease_type == "skin":
+        model, classes = app.state.cat_skin
+    else:
+        return {"error": "Invalid input"}
+
+    from backend.services.predictor import predict
+    return predict(model, classes, tensor)

backend/utils/image.py

@@ -0,0 +1,13 @@
+from PIL import Image
+import torchvision.transforms as transforms
+
+transform = transforms.Compose([
+    transforms.Resize((224,224)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485,0.456,0.406],
+                         [0.229,0.224,0.225])
+])
+
+def preprocess(image_bytes):
+    image = Image.open(image_bytes).convert("RGB")
+    return transform(image).unsqueeze(0)

weights/cat_skin_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f454a8526359edd258af304d0f62c8e6e3931232ef96fcd4e69d4cd2d2176ff
+size 94385321

weights/dog_eye_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e9db83fc5e31b46612e23fac2b3fc104f60e5987b96a1b5002e44ec65145aaa
+size 94393187

weights/dog_eye_model_ResNet_NEW.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ffef2d414b30090a756ab3d77be1b9ab2dc7ce82155a63449c046f34afcdcfcf
+size 94396901

weights/dog_skin_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:649617acc0d788d10bebe214af294faf447fce5258bac44f3c1b8e4b6f05b29d
+size 94401769