production release

src/backend/app/db/database.py

@@ -9,7 +9,9 @@
 
 async def get_db_connection_pool() -> AsyncConnectionPool:
     """Get the connection pool for psycopg."""
-    return AsyncConnectionPool(conninfo=settings.DTM_DB_URL.unicode_string())
+    pool = AsyncConnectionPool(conninfo=settings.DTM_DB_URL.unicode_string())
+    await pool.open()  # Explicitly open the pool
+    return pool
 
 
 async def get_db(request: Request) -> AsyncGenerator[Connection, None]:

src/backend/app/main.py

@@ -7,14 +7,13 @@
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.templating import Jinja2Templates
 from fastapi.responses import RedirectResponse, JSONResponse
-
+from psycopg_pool import AsyncConnectionPool
 from app.config import settings
 from app.projects import project_routes
 from app.drones import drone_routes
 from app.waypoints import waypoint_routes
 from app.users import user_routes
 from app.tasks import task_routes
-from app.db.database import get_db_connection_pool
 
 
 root = os.path.dirname(os.path.abspath(__file__))
@@ -105,23 +104,19 @@ def get_application() -> FastAPI:
 
 
 @asynccontextmanager
-async def lifespan(
-    app: FastAPI,
-):
+async def lifespan(app: FastAPI):
     """FastAPI startup/shutdown event."""
     log.debug("Starting up FastAPI server.")
 
-    db_pool = await get_db_connection_pool()
-    await db_pool.open()
-    # Create a pooled db connection and make available in app state
-    # NOTE we can access 'request.app.state.db_pool' in endpoints
-    app.state.db_pool = db_pool
-
-    yield
+    async with AsyncConnectionPool(
+        conninfo=settings.DTM_DB_URL.unicode_string()
+    ) as db_pool:
+        # The pool is now used within the context manager
+        app.state.db_pool = db_pool
+        yield  # FastAPI will run the application here
 
-    # Shutdown events
+    # Pool will be closed automatically when the context manager exits
     log.debug("Shutting down FastAPI server.")
-    await app.state.db_pool.close()
 
 
 api = get_application()

src/backend/app/projects/project_deps.py

@@ -7,13 +7,35 @@
 from fastapi import Depends, HTTPException, Path, File, UploadFile
 from psycopg import Connection
 from geojson import FeatureCollection
-
+from psycopg.rows import dict_row
 from app.db import database
 from app.models.enums import HTTPStatus
 from app.projects.project_schemas import DbProject
 from app.utils import multipolygon_to_polygon
 
 
+async def get_tasks_by_project_id(project_id: UUID, db: Connection):
+    """Get tasks by project id."""
+    try:
+        async with db.cursor(row_factory=dict_row) as cur:
+            await cur.execute(
+                """SELECT id FROM tasks WHERE project_id = %(project_id)s""",
+                {"project_id": project_id},
+            )
+
+            data = await cur.fetchall()
+
+            if data is None:
+                raise HTTPException(
+                    status_code=HTTPStatus.FORBIDDEN,
+                    detail="No tasks found for this project.",
+                )
+            return data
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 async def get_project_by_id(
     project_id: Annotated[
         UUID,
@@ -27,7 +49,7 @@ async def get_project_by_id(
     try:
         return await DbProject.one(db, project_id)
     except KeyError as e:
-        raise HTTPException(status_code=HTTPStatus.NOT_FOUND) from e
+        raise HTTPException(status_code=HTTPStatus.FORBIDDEN) from e
 
 
 async def geojson_upload(

src/backend/app/projects/project_routes.py

@@ -388,17 +388,34 @@ async def process_imagery(
 
 
 @router.get(
-    "/assets/{project_id}/{task_id}/",
+    "/assets/{project_id}/",
     tags=["Image Processing"],
-    response_model=project_schemas.AssetsInfo,
 )
 async def get_assets_info(
+    user_data: Annotated[AuthUser, Depends(login_required)],
+    db: Annotated[Connection, Depends(database.get_db)],
     project: Annotated[
         project_schemas.DbProject, Depends(project_deps.get_project_by_id)
     ],
-    task_id: uuid.UUID,
+    task_id: Optional[uuid.UUID] = None,
 ):
     """
-    Endpoint to get the number of images and the URL to download the assets for a given project and task.
+    Endpoint to get the number of images and the URL to download the assets
+    for a given project and task. If no task_id is provided, returns info
+    for all tasks associated with the project.
     """
-    return project_logic.get_project_info_from_s3(project.id, task_id)
+    if task_id is None:
+        # Fetch all tasks associated with the project
+        tasks = await project_deps.get_tasks_by_project_id(project.id, db)
+
+        results = []
+
+        for task in tasks:
+            task_info = project_logic.get_project_info_from_s3(
+                project.id, task.get("id")
+            )
+            results.append(task_info)
+
+        return results
+    else:
+        return project_logic.get_project_info_from_s3(project.id, task_id)

src/backend/app/projects/project_schemas.py

@@ -2,7 +2,6 @@
 import uuid
 from typing import Annotated, Optional, List
 from datetime import datetime, date
-from app.projects import project_logic
 import geojson
 from loguru import logger as log
 from pydantic import BaseModel, computed_field, Field, model_validator, root_validator
@@ -147,24 +146,6 @@ class TaskOut(BaseModel):
     image_count: Optional[int] = None
     assets_url: Optional[str] = None
 
-    @model_validator(mode="after")
-    def set_assets_url(cls, values):
-        """Set image_url and image count before rendering the model."""
-        task_id = values.id
-        project_id = values.project_id
-
-        if task_id and project_id:
-            data = project_logic.get_project_info_from_s3(project_id, task_id)
-            if data:
-                return values.copy(
-                    update={
-                        "assets_url": data.assets_url,
-                        "image_count": data.image_count,
-                    }
-                )
-
-        return values
-
 
 class DbProject(BaseModel):
     """Project model for extracting from database."""
@@ -549,12 +530,12 @@ def calculate_status(cls, values):
         completed_task_count = values.completed_task_count
         total_task_count = values.total_task_count
 
-        if ongoing_task_count == 0:
+        if completed_task_count == 0 and ongoing_task_count == 0:
             values.status = "not-started"
-        elif ongoing_task_count > 0 and ongoing_task_count != completed_task_count:
-            values.status = "ongoing"
-        elif ongoing_task_count == total_task_count:
+        elif completed_task_count == total_task_count:
             values.status = "completed"
+        else:
+            values.status = "ongoing"
 
         return values
 

src/backend/app/tasks/task_routes.py

@@ -96,7 +96,7 @@ async def get_task_stats(
             raw_sql = """
                 SELECT
                     COUNT(CASE WHEN te.state = 'REQUEST_FOR_MAPPING' THEN 1 END) AS request_logs,
-                    COUNT(CASE WHEN te.state = 'LOCKED_FOR_MAPPING' THEN 1 END) AS ongoing_tasks,
+                    COUNT(CASE WHEN te.state IN ('LOCKED_FOR_MAPPING', 'REQUEST_FOR_MAPPING', 'IMAGE_UPLOADED', 'UNFLYABLE_TASK') THEN 1 END) AS ongoing_tasks,
                     COUNT(CASE WHEN te.state = 'IMAGE_PROCESSED' THEN 1 END) AS completed_tasks,
                     COUNT(CASE WHEN te.state = 'UNFLYABLE_TASK' THEN 1 END) AS unflyable_tasks
                 FROM (