cloudinary upload

.env

@@ -1,3 +1,6 @@
 JWT_SECRET_KEY=change_this_secret_in_production
 MONGODB_URI=mongodb+srv://deepdblm_db_user:IqLKnKhwLLSOP1Ka@cluster0.0u1vpow.mongodb.net/?retryWrites=true&w=majority&appName=Cluster0
-ALLOWED_ORIGINS=http://localhost:8080,https://marine-pollution-detection.vercel.app
+ALLOWED_ORIGINS=http://localhost:8080,https://marine-pollution-detection.vercel.app
+CLOUDINARY_CLOUD_NAME=dler9jdjf
+CLOUDINARY_API_KEY=414766445792264
+CLOUDINARY_API_SECRET=kV133xtcDbxh4tEMvk5CS4WFx1U

app/config.py

@@ -1,6 +1,7 @@
 from functools import lru_cache
 from typing import List, Union
 import os
+import cloudinary
 
 from pydantic_settings import BaseSettings
 
@@ -14,6 +15,11 @@ class Settings(BaseSettings):
     access_token_expire_minutes: int = 60 * 24
     allowed_origins: Union[str, List[str]] = "http://localhost:5173"
     
+    # Cloudinary settings
+    cloudinary_cloud_name: str
+    cloudinary_api_key: str
+    cloudinary_api_secret: str
+    
     # Hugging Face Spaces specific settings
     space_id: str = os.getenv("SPACE_ID", "")
     

app/main.py

@@ -1,5 +1,7 @@
 import logging
 from contextlib import asynccontextmanager
+import cloudinary
+import sys
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
@@ -8,6 +10,14 @@ from .config import get_settings
 from .database import get_collection, test_connection
 from .routers import auth, incidents
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.StreamHandler(sys.stdout)
+    ]
+)
 logger = logging.getLogger(__name__)
 
 
@@ -35,6 +45,21 @@ async def setup_database_indexes():
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     # Startup
+    settings = get_settings()
+    
+    # Initialize Cloudinary
+    try:
+        # Use environment variables from settings
+        cloudinary.config(
+            cloud_name=settings.cloudinary_cloud_name,
+            api_key=settings.cloudinary_api_key,
+            api_secret=settings.cloudinary_api_secret,
+            secure=True
+        )
+        logger.info("Cloudinary initialized successfully with cloud name: %s", settings.cloudinary_cloud_name)
+    except Exception as e:
+        logger.error(f"Cloudinary initialization failed: {e}")
+    
     await setup_database_indexes()
     yield
     # Shutdown (if needed in future)

app/routers/incidents.py

@@ -45,7 +45,16 @@ async def classify_incident_report(
             incident_class, severity = classification_result
             confidence_scores = None
 
-        image_path = await store_image(image)
+        # Upload image to Cloudinary
+        image_path = None
+        if image:
+            image_path = await store_image(image)
+            if not image_path:
+                # If Cloudinary upload fails, raise an error since we're not using local fallback
+                raise HTTPException(
+                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+                    detail="Failed to upload image to cloud storage"
+                )
 
         document = {
             "name": name,

app/services/fallback_storage.py

@@ -0,0 +1,61 @@
+"""
+Fallback storage service for when Cloudinary uploads fail.
+This provides a more controlled way to handle local storage fallback.
+"""
+from pathlib import Path
+from typing import Optional
+import logging
+from uuid import uuid4
+
+logger = logging.getLogger(__name__)
+
+# Define fallback upload directories
+FALLBACK_PATHS = [
+    Path(__file__).resolve().parent.parent / "uploads",
+    Path("/tmp/uploads"),
+    Path("/app/uploads")
+]
+
+# Find a usable directory
+FALLBACK_DIR = None
+for path in FALLBACK_PATHS:
+    try:
+        path.mkdir(exist_ok=True, parents=True)
+        FALLBACK_DIR = path
+        logger.info(f"Fallback storage directory ready: {FALLBACK_DIR}")
+        break
+    except Exception as e:
+        logger.warning(f"Cannot use {path} for fallback storage: {e}")
+        continue
+
+if FALLBACK_DIR is None:
+    logger.error("Could not create any fallback storage directory")
+    FALLBACK_DIR = Path("/tmp")  # Last resort fallback
+
+
+async def store_file_locally(file_content: bytes, original_filename: str) -> Optional[str]:
+    """
+    Store a file in the local filesystem as a fallback when cloud storage fails
+    
+    Args:
+        file_content: The binary content of the file
+        original_filename: The original filename
+        
+    Returns:
+        Relative path to the stored file or None if storage failed
+    """
+    try:
+        # Create a unique filename
+        file_extension = Path(original_filename).suffix
+        filename = f"{uuid4().hex}{file_extension}"
+        file_path = FALLBACK_DIR / filename
+        
+        # Write the file
+        file_path.write_bytes(file_content)
+        logger.info(f"File saved to fallback storage: {file_path}")
+        
+        # Return a relative path that can be used in URLs
+        return str(Path("uploads") / filename)
+    except Exception as e:
+        logger.error(f"Failed to save file to fallback storage: {e}")
+        return None

app/services/incidents.py

@@ -2,38 +2,18 @@ from pathlib import Path
 from typing import Optional
 from uuid import uuid4
 import logging
+import cloudinary
+import cloudinary.uploader
+import tempfile
+import os
 
 from ..database import get_collection
+from ..config import get_settings
 
 logger = logging.getLogger(__name__)
 
 INCIDENTS_COLLECTION = "incidents"
 
-# Try multiple upload directory locations
-upload_paths = [
-    Path(__file__).resolve().parent.parent / "uploads",
-    Path("/tmp/uploads"),
-    Path("/app/uploads")
-]
-
-UPLOAD_DIR = None
-for path in upload_paths:
-    try:
-        path.mkdir(exist_ok=True, parents=True)
-        UPLOAD_DIR = path
-        logger.info(f"Upload directory ready: {UPLOAD_DIR}")
-        break
-    except PermissionError:
-        logger.warning(f"Cannot create upload directory at {path}")
-        continue
-    except Exception as e:
-        logger.warning(f"Error creating upload directory at {path}: {e}")
-        continue
-
-if UPLOAD_DIR is None:
-    logger.error("Could not create any upload directory")
-    UPLOAD_DIR = Path("/tmp")  # Fallback to /tmp
-
 
 async def save_incident_document(document: dict) -> dict:
     collection = get_collection(INCIDENTS_COLLECTION)
@@ -57,16 +37,54 @@ async def get_all_incidents() -> list:
 
 
 async def store_image(upload_file) -> Optional[str]:
+    """
+    Store an uploaded image using Cloudinary only.
+    No local fallback - if Cloudinary upload fails, the function will return None.
+    """
     if upload_file is None:
         return None
-
-    UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
-    file_extension = Path(upload_file.filename).suffix
-    filename = f"{uuid4().hex}{file_extension}"
-    file_path = UPLOAD_DIR / filename
-
-    contents = await upload_file.read()
-    file_path.write_bytes(contents)
-
-    await upload_file.close()
-    return str(Path("uploads") / filename)
+    
+    temp_path = None
+    try:
+        logger.info(f"Starting image upload to Cloudinary for file: {upload_file.filename}")
+        
+        # Read the file content
+        contents = await upload_file.read()
+        logger.info(f"Read {len(contents)} bytes from uploaded file")
+        
+        # Create a temporary file to use with Cloudinary
+        with tempfile.NamedTemporaryFile(delete=False, suffix=Path(upload_file.filename).suffix) as temp_file:
+            temp_path = temp_file.name
+            temp_file.write(contents)
+            logger.info(f"Wrote content to temporary file: {temp_path}")
+        
+        # Upload to Cloudinary - ensuring we use the right resource type
+        logger.info("Starting Cloudinary upload...")
+        
+        # Add resource_type=auto to handle different file types correctly
+        upload_result = cloudinary.uploader.upload(
+            temp_path,
+            folder="marine_guard_incidents",
+            resource_type="auto"
+        )
+        
+        # Return the Cloudinary URL
+        cloudinary_url = upload_result["secure_url"]
+        logger.info(f"Cloudinary upload successful. URL: {cloudinary_url}")
+        
+        await upload_file.close()
+        return cloudinary_url
+    
+    except Exception as e:
+        logger.error(f"Failed to upload image to Cloudinary: {e}", exc_info=True)
+        if upload_file:
+            await upload_file.close()
+        return None
+    finally:
+        # Always clean up the temporary file
+        if temp_path and os.path.exists(temp_path):
+            try:
+                os.unlink(temp_path)
+                logger.info(f"Deleted temporary file: {temp_path}")
+            except Exception as e:
+                logger.error(f"Failed to delete temporary file: {e}")

app/uploads/222544d2e2e44e8d812becab341d74ef.txt

@@ -0,0 +1 @@
+This is a test image file for the API

create_test_user.py

@@ -0,0 +1,44 @@
+import requests
+import json
+
+# API endpoint for user signup
+API_URL = "http://localhost:8000/api/auth/signup"
+
+def create_test_user():
+    """Create a test user for API testing"""
+    try:
+        # Prepare the user data
+        user_data = {
+            "email": "testuser@example.com",
+            "password": "Password123!",
+            "display_name": "Test User",
+            "organization": "Test Org",
+            "role": "citizen"
+        }
+        
+        # Make the API request
+        print(f"Creating test user at {API_URL}")
+        response = requests.post(
+            API_URL,
+            data=json.dumps(user_data),
+            headers={"Content-Type": "application/json"}
+        )
+        
+        # Process the response
+        if response.status_code == 200:
+            result = response.json()
+            print("User created successfully!")
+            print(f"Token: {result.get('access_token')[:15]}...")
+            print(f"User ID: {result.get('user', {}).get('id')}")
+            return result
+        else:
+            print(f"API request failed with status code {response.status_code}")
+            print(f"Response: {response.text}")
+            return None
+    except Exception as e:
+        print(f"Error creating test user: {e}")
+        return None
+
+if __name__ == "__main__":
+    print("Creating test user for Marine Guard API")
+    create_test_user()

debug_cloudinary.py

@@ -0,0 +1,66 @@
+import os
+import cloudinary
+import cloudinary.uploader
+from dotenv import load_dotenv
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+# Configure Cloudinary
+cloudinary.config(
+    cloud_name=os.getenv("CLOUDINARY_CLOUD_NAME"),
+    api_key=os.getenv("CLOUDINARY_API_KEY"),
+    api_secret=os.getenv("CLOUDINARY_API_SECRET"),
+    secure=True
+)
+
+def test_cloudinary_config():
+    print("Cloudinary configuration:")
+    print(f"Cloud name: {cloudinary.config().cloud_name}")
+    print(f"API key: {cloudinary.config().api_key}")
+    print(f"API secret: {'*' * len(cloudinary.config().api_secret) if cloudinary.config().api_secret else 'Not set'}")
+
+def upload_test_image():
+    try:
+        # Create a test file
+        test_file_path = "cloudinary_test.txt"
+        with open(test_file_path, "w") as f:
+            f.write("Test content for Cloudinary upload")
+        
+        # Upload to Cloudinary
+        print("Uploading test file to Cloudinary...")
+        upload_result = cloudinary.uploader.upload(
+            test_file_path,
+            folder="marine_guard_test",
+            resource_type="auto"  # Let Cloudinary auto-detect the resource type
+        )
+        
+        print(f"Upload successful! URL: {upload_result.get('secure_url')}")
+        print(f"Public ID: {upload_result.get('public_id')}")
+        print(f"Resource type: {upload_result.get('resource_type')}")
+        
+        # Clean up the test file
+        os.unlink(test_file_path)
+        print(f"Deleted local test file: {test_file_path}")
+        
+        return upload_result
+    
+    except Exception as e:
+        logger.error(f"Error uploading to Cloudinary: {e}", exc_info=True)
+        if os.path.exists(test_file_path):
+            os.unlink(test_file_path)
+        return None
+
+if __name__ == "__main__":
+    print("Testing detailed Cloudinary configuration and upload")
+    test_cloudinary_config()
+    result = upload_test_image()
+    if result:
+        print("✅ Cloudinary upload test PASSED")
+    else:
+        print("❌ Cloudinary upload test FAILED")

list_incidents.py

@@ -0,0 +1,78 @@
+import requests
+import json
+
+# API endpoint for incident listing
+API_URL = "http://localhost:8000/api/incidents/list"
+
+def get_token():
+    """Get a JWT token by authenticating with the API"""
+    try:
+        login_url = "http://localhost:8000/api/auth/login"
+        login_data = {
+            "email": "testuser@example.com",
+            "password": "Password123!"
+        }
+        
+        response = requests.post(login_url, data=json.dumps(login_data), 
+                                headers={"Content-Type": "application/json"})
+        
+        if response.status_code == 200:
+            token = response.json().get("access_token")
+            print(f"Authentication successful.")
+            return token
+        else:
+            print(f"Authentication failed with status code {response.status_code}")
+            print(response.text)
+            return None
+    except Exception as e:
+        print(f"Error getting token: {e}")
+        return None
+
+def list_incidents():
+    """List all incidents for the authenticated user"""
+    token = get_token()
+    if not token:
+        print("No token available, cannot proceed")
+        return
+    
+    try:
+        print(f"Fetching incidents from {API_URL}")
+        response = requests.get(
+            API_URL,
+            headers={"Authorization": f"Bearer {token}"}
+        )
+        
+        if response.status_code == 200:
+            incidents = response.json().get("incidents", [])
+            print(f"Found {len(incidents)} incidents")
+            
+            # Print details of each incident
+            for i, incident in enumerate(incidents):
+                print(f"\nIncident {i + 1}:")
+                print(f"  ID: {incident.get('id')}")
+                print(f"  Type: {incident.get('incident_class')}")
+                print(f"  Severity: {incident.get('severity')}")
+                print(f"  Created: {incident.get('created_at')}")
+                
+                # Check if image path is a Cloudinary URL
+                image_path = incident.get('image_path')
+                if image_path:
+                    if 'cloudinary.com' in image_path:
+                        print(f"  Image: Cloudinary URL - {image_path}")
+                    else:
+                        print(f"  Image: Local path - {image_path}")
+                else:
+                    print("  No image attached")
+            
+            return incidents
+        else:
+            print(f"API request failed with status code {response.status_code}")
+            print(f"Response: {response.text}")
+            return None
+    except Exception as e:
+        print(f"Error listing incidents: {e}")
+        return None
+
+if __name__ == "__main__":
+    print("Listing incidents from Marine Guard API")
+    list_incidents()

test_api_cloudinary.py

@@ -0,0 +1,118 @@
+import os
+import requests
+import json
+import sys
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# API endpoint for incident classification
+API_URL = "http://localhost:8000/api/incidents/classify"
+
+# JWT token (replace with your actual token)
+JWT_TOKEN = ""  # Set this to test with your token
+
+def get_token():
+    """Get a JWT token by authenticating with the API"""
+    try:
+        login_url = "http://localhost:8000/api/auth/login"
+        login_data = {
+            "email": "testuser@example.com",  # Using our newly created test user
+            "password": "Password123!"         # Using the password for the test user
+        }
+        
+        response = requests.post(login_url, data=json.dumps(login_data), 
+                                headers={"Content-Type": "application/json"})
+        
+        if response.status_code == 200:
+            token = response.json().get("access_token")
+            print(f"Authentication successful. Token: {token[:15]}..." if token else "No token in response")
+            return token
+        else:
+            print(f"Authentication failed with status code {response.status_code}")
+            print(response.text)
+            return None
+    except Exception as e:
+        print(f"Error getting token: {e}")
+        return None
+
+def create_test_image():
+    """Create a test image file"""
+    # Check if we're in the right directory
+    current_dir = Path.cwd()
+    print(f"Current directory: {current_dir}")
+    
+    # Create a directory for test files if it doesn't exist
+    test_dir = current_dir / "test_files"
+    test_dir.mkdir(exist_ok=True)
+    
+    # Path to the test image file
+    test_image_path = test_dir / "test_image.txt"
+    
+    # Write some content to the file
+    with open(test_image_path, "w") as f:
+        f.write("This is a test image file for the API")
+    
+    print(f"Created test file at {test_image_path}")
+    return test_image_path
+
+def test_report_incident_with_image():
+    """Test reporting an incident with an image"""
+    
+    # Create a test image
+    image_path = create_test_image()
+    
+    # Get a token if not provided
+    token = JWT_TOKEN or get_token()
+    if not token:
+        print("No token available, cannot proceed with test")
+        return
+    
+    try:
+        # Prepare the form data
+        form_data = {
+            "description": "Test incident with image upload to Cloudinary",
+            "name": "Cloudinary Test",
+            "latitude": "37.7749",
+            "longitude": "-122.4194"
+        }
+        
+        # Prepare the file
+        with open(image_path, "rb") as image_file:
+            files = {"image": ("test_image.txt", image_file, "text/plain")}
+            
+            # Make the API request
+            print(f"Sending request to {API_URL}")
+            response = requests.post(
+                API_URL,
+                data=form_data,
+                files=files,
+                headers={"Authorization": f"Bearer {token}"}
+            )
+            
+        # Process the response
+        if response.status_code == 200:
+            print("Incident report successful!")
+            print(f"Response: {response.json()}")
+            return response.json()
+        else:
+            print(f"API request failed with status code {response.status_code}")
+            print(f"Response: {response.text}")
+            return None
+    except Exception as e:
+        print(f"Error testing incident report API: {e}")
+        return None
+    finally:
+        # Clean up test image
+        try:
+            if os.path.exists(image_path):
+                os.remove(image_path)
+                print(f"Removed test file: {image_path}")
+        except Exception as e:
+            print(f"Error cleaning up test file: {e}")
+
+if __name__ == "__main__":
+    print("Testing Marine Guard Incident API with Cloudinary Integration")
+    test_report_incident_with_image()

test_cloudinary.py

@@ -0,0 +1,52 @@
+import os
+import cloudinary
+import cloudinary.uploader
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Configure Cloudinary
+cloudinary.config(
+    cloud_name=os.getenv("CLOUDINARY_CLOUD_NAME"),
+    api_key=os.getenv("CLOUDINARY_API_KEY"),
+    api_secret=os.getenv("CLOUDINARY_API_SECRET"),
+    secure=True
+)
+
+def test_cloudinary_upload():
+    """Test Cloudinary upload functionality"""
+    try:
+        # Try to upload a simple text as a test
+        # Create a simple test file
+        test_file = "test_image.txt"
+        with open(test_file, "w") as f:
+            f.write("This is a test file for Cloudinary upload")
+            
+        # Upload to Cloudinary
+        print("Uploading to Cloudinary...")
+        result = cloudinary.uploader.upload(
+            test_file,
+            folder="marine_guard_test",
+            public_id="test_upload"
+        )
+        
+        print(f"Upload successful! URL: {result['secure_url']}")
+        print(f"Full result: {result}")
+        
+        # Clean up the test file
+        os.remove(test_file)
+        return True
+        
+    except Exception as e:
+        print(f"Error testing Cloudinary upload: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("Testing Cloudinary configuration")
+    print(f"Cloud name: {os.getenv('CLOUDINARY_CLOUD_NAME')}")
+    print(f"API key: {os.getenv('CLOUDINARY_API_KEY')}")
+    print(f"API secret: {os.getenv('CLOUDINARY_API_SECRET')[:3]}...")
+    
+    test_result = test_cloudinary_upload()
+    print(f"Test {'successful' if test_result else 'failed'}")

test_cloudinary_improved.py

@@ -0,0 +1,157 @@
+import os
+import requests
+import json
+from pathlib import Path
+from dotenv import load_dotenv
+import random
+
+# Load environment variables
+load_dotenv()
+
+# API endpoint for incident classification
+API_URL = "http://localhost:8000/api/incidents/classify"
+
+def get_token():
+    """Get a JWT token by authenticating with the API"""
+    try:
+        login_url = "http://localhost:8000/api/auth/login"
+        login_data = {
+            "email": "testuser@example.com",
+            "password": "Password123!"
+        }
+        
+        response = requests.post(login_url, data=json.dumps(login_data), 
+                                headers={"Content-Type": "application/json"})
+        
+        if response.status_code == 200:
+            token = response.json().get("access_token")
+            print(f"Authentication successful. Token: {token[:15]}...")
+            return token
+        else:
+            print(f"Authentication failed with status code {response.status_code}")
+            print(response.text)
+            return None
+    except Exception as e:
+        print(f"Error getting token: {e}")
+        return None
+
+def create_test_image():
+    """Create a test image file - we'll use a .jpg extension but with text content for testing"""
+    # Create a directory for test files if it doesn't exist
+    test_dir = Path("test_files")
+    test_dir.mkdir(exist_ok=True)
+    
+    # Use a .jpg extension to make sure Cloudinary tries to process it properly
+    test_image_path = test_dir / f"test_image_{random.randint(1000, 9999)}.jpg"
+    
+    # Write some content to the file
+    with open(test_image_path, "w") as f:
+        f.write("This is a fake image file for testing Cloudinary uploads")
+    
+    print(f"Created test file at {test_image_path}")
+    return test_image_path
+
+def report_incident_with_image():
+    """Report an incident with an image via the API"""
+    # Create a test image
+    image_path = create_test_image()
+    
+    # Get a token
+    token = get_token()
+    if not token:
+        print("No token available, cannot proceed with test")
+        return False
+    
+    try:
+        # Prepare the form data
+        form_data = {
+            "description": "Testing Cloudinary integration with improved logging",
+            "name": "Cloudinary Test",
+            "latitude": "37.7749",
+            "longitude": "-122.4194"
+        }
+        
+        # Prepare the file
+        with open(image_path, "rb") as image_file:
+            files = {"image": (image_path.name, image_file, "image/jpeg")}
+            
+            # Make the API request
+            print(f"Sending request to {API_URL}")
+            response = requests.post(
+                API_URL,
+                data=form_data,
+                files=files,
+                headers={"Authorization": f"Bearer {token}"}
+            )
+        
+        # Process the response
+        if response.status_code == 200:
+            print("Incident report successful!")
+            print(f"Response: {response.json()}")
+            
+            # Get the incident ID from the response
+            incident_id = response.json().get("incident_id")
+            print(f"Created incident with ID: {incident_id}")
+            
+            # Now check the incident details to see if Cloudinary URL was used
+            if incident_id:
+                return check_incident_image(token, incident_id)
+            return True
+        else:
+            print(f"API request failed with status code {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"Error testing incident report API: {e}")
+        return False
+    finally:
+        # Clean up test image
+        try:
+            if image_path.exists():
+                image_path.unlink()
+                print(f"Removed test file: {image_path}")
+        except Exception as e:
+            print(f"Error cleaning up test file: {e}")
+
+def check_incident_image(token, incident_id):
+    """Check if the incident has a Cloudinary image URL"""
+    try:
+        # Get the list of incidents
+        list_url = "http://localhost:8000/api/incidents/list"
+        print(f"Fetching incidents to check for Cloudinary URL...")
+        
+        response = requests.get(
+            list_url,
+            headers={"Authorization": f"Bearer {token}"}
+        )
+        
+        if response.status_code == 200:
+            incidents = response.json().get("incidents", [])
+            
+            # Find our incident
+            for incident in incidents:
+                if incident.get("id") == incident_id:
+                    image_path = incident.get("image_path")
+                    print(f"Found incident. Image path: {image_path}")
+                    
+                    if image_path and "cloudinary.com" in image_path:
+                        print("✅ SUCCESS: Image was uploaded to Cloudinary!")
+                        return True
+                    else:
+                        print("❌ FAILED: Image was not uploaded to Cloudinary")
+                        return False
+            
+            print(f"Couldn't find incident with ID: {incident_id}")
+            return False
+        else:
+            print(f"Failed to fetch incidents list: {response.status_code}")
+            print(response.text)
+            return False
+    except Exception as e:
+        print(f"Error checking incident: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("Testing Marine Guard incident reporting with Cloudinary integration")
+    success = report_incident_with_image()
+    print(f"Test {'PASSED' if success else 'FAILED'}")

test_cloudinary_mandatory.py

@@ -0,0 +1,162 @@
+"""
+Test script for Cloudinary-only image storage in the Marine Guard API.
+This script ensures that:
+1. We can authenticate with the API
+2. We can upload an image which gets stored in Cloudinary
+3. We can retrieve the incident which contains the Cloudinary URL
+"""
+import os
+import requests
+import json
+from pathlib import Path
+import random
+import time
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# API endpoint for incident classification
+API_URL = "http://localhost:8000/api/incidents/classify"
+API_LIST_URL = "http://localhost:8000/api/incidents/list"
+API_LOGIN_URL = "http://localhost:8000/api/auth/login"
+
+def authenticate():
+    """Authenticate with the API and get a JWT token"""
+    try:
+        login_data = {
+            "email": "testuser@example.com",
+            "password": "Password123!"
+        }
+        
+        print(f"Authenticating with the API at {API_LOGIN_URL}...")
+        response = requests.post(API_LOGIN_URL, json=login_data)
+        
+        if response.status_code == 200:
+            token = response.json().get("access_token")
+            print("✅ Authentication successful!")
+            return token
+        else:
+            print(f"❌ Authentication failed with status code {response.status_code}")
+            print(response.text)
+            return None
+    except Exception as e:
+        print(f"❌ Error during authentication: {e}")
+        return None
+
+def create_test_file():
+    """Create a test file to upload"""
+    test_dir = Path("test_files")
+    test_dir.mkdir(exist_ok=True)
+    
+    # Use a .txt extension since we just need any file that Cloudinary can handle
+    file_path = test_dir / f"cloudinary_test_{random.randint(1000, 9999)}.txt"
+    
+    # Write simple text content
+    with open(file_path, "w") as f:
+        f.write("This is a test file for Cloudinary upload in Marine Guard API")
+        
+    print(f"Created test file at: {file_path}")
+    return file_path
+
+def report_incident():
+    """Report an incident with an image via the API"""
+    token = authenticate()
+    if not token:
+        print("Cannot proceed with test - authentication failed")
+        return False
+    
+    # Create a test image file
+    image_path = create_test_file()
+    
+    try:
+        # Prepare the form data
+        form_data = {
+            "description": "Cloudinary-only storage test with JPG image",
+            "name": "Cloudinary Storage Test",
+            "latitude": "42.3601",
+            "longitude": "-71.0589"
+        }
+        
+        # Prepare the file for upload
+        with open(image_path, "rb") as image_file:
+            files = {"image": (image_path.name, image_file, "text/plain")}
+            
+            # Make the API request
+            print(f"Reporting incident to {API_URL}...")
+            response = requests.post(
+                API_URL,
+                data=form_data,
+                files=files,
+                headers={"Authorization": f"Bearer {token}"}
+            )
+        
+        # Check the response
+        if response.status_code == 200:
+            result = response.json()
+            incident_id = result.get("incident_id")
+            print(f"✅ Incident reported successfully! ID: {incident_id}")
+            
+            # Verify that the image was uploaded to Cloudinary
+            return verify_cloudinary_upload(token, incident_id)
+        else:
+            print(f"❌ Incident reporting failed with status code {response.status_code}")
+            print(f"Error details: {response.text}")
+            return False
+    except Exception as e:
+        print(f"❌ Error reporting incident: {e}")
+        return False
+    finally:
+        # Clean up the test file
+        if os.path.exists(image_path):
+            os.unlink(image_path)
+            print(f"Deleted test file: {image_path}")
+
+def verify_cloudinary_upload(token, incident_id):
+    """Verify that the incident has a Cloudinary URL for its image"""
+    try:
+        print(f"Fetching incident details to verify Cloudinary URL...")
+        # Short delay to ensure the incident is saved in the database
+        time.sleep(1)
+        
+        response = requests.get(
+            API_LIST_URL,
+            headers={"Authorization": f"Bearer {token}"}
+        )
+        
+        if response.status_code == 200:
+            incidents = response.json().get("incidents", [])
+            for incident in incidents:
+                if incident.get("id") == incident_id:
+                    image_path = incident.get("image_path")
+                    
+                    if image_path and "cloudinary.com" in image_path:
+                        print(f"✅ SUCCESS: Image was uploaded to Cloudinary!")
+                        print(f"Cloudinary URL: {image_path}")
+                        return True
+                    else:
+                        print(f"❌ FAILED: Image does not have a Cloudinary URL")
+                        print(f"Image path: {image_path}")
+                        return False
+            
+            print(f"❌ FAILED: Could not find incident with ID {incident_id}")
+            return False
+        else:
+            print(f"❌ FAILED: Could not fetch incidents list. Status: {response.status_code}")
+            print(response.text)
+            return False
+    except Exception as e:
+        print(f"❌ Error verifying Cloudinary upload: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("MARINE GUARD API - CLOUDINARY-ONLY STORAGE TEST")
+    print("=" * 60)
+    
+    success = report_incident()
+    
+    print("\nTEST SUMMARY")
+    print("=" * 60)
+    print(f"Cloudinary storage test: {'✅ PASSED' if success else '❌ FAILED'}")
+    print("=" * 60)

test_image.txt

@@ -0,0 +1 @@
+This is a test file for Cloudinary upload