Persistence/manager management modal

backend_py/primary/primary/auth/enforce_logged_in_middleware.py

@@ -128,8 +128,10 @@ async def dispatch(self, request: Request, call_next: RequestResponseEndpoint) -
 
         path_is_protected = True
 
-        if path_to_check in ["/login", "/auth-callback"] + self._unprotected_paths:
-            path_is_protected = False
+        for unprotected in ["/login", "/auth-callback"] + self._unprotected_paths:
+            if path_to_check.startswith(unprotected):
+                path_is_protected = False
+                break
 
         if path_is_protected:
 

backend_py/primary/primary/config.py

@@ -33,3 +33,11 @@
 DEFAULT_STALE_WHILE_REVALIDATE = 3600 * 24  # 24 hour
 REDIS_USER_SESSION_URL = "redis://redis-user-session:6379"
 REDIS_CACHE_URL = "redis://redis-cache:6379"
+
+COSMOS_DB_PROD_CONNECTION_STRING = os.environ.get("WEBVIZ_DB_CONNECTION_STRING", None)
+# pylint: disable=line-too-long
+COSMOS_DB_EMULATOR_URI = "https://host.docker.internal:8081/"
+COSMOS_DB_EMULATOR_KEY = "C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw==;"
+
+PERSISTENCE_DB_NAME = "persistence"
+DASHBOARDS_CONTAINER_NAME = "dashboards"

backend_py/primary/primary/main.py

@@ -12,6 +12,7 @@
 from primary.auth.auth_helper import AuthHelper
 from primary.auth.enforce_logged_in_middleware import EnforceLoggedInMiddleware
 from primary.middleware.add_process_time_to_server_timing_middleware import AddProcessTimeToServerTimingMiddleware
+from primary.services.database_access.setup_local_database import maybe_setup_local_database
 
 from primary.middleware.add_browser_cache import AddBrowserCacheMiddleware
 from primary.routers.dev.router import router as dev_router
@@ -32,6 +33,9 @@
 from primary.routers.vfp.router import router as vfp_router
 from primary.routers.well.router import router as well_router
 from primary.routers.well_completions.router import router as well_completions_router
+from primary.routers.persistence.sessions.router import router as sessions_router
+from primary.routers.persistence.snapshots.router import router as snapshots_router
+from primary.routers.persistence.snapshot_preview.router import router as snapshot_preview_router
 from primary.services.utils.httpx_async_client_wrapper import HTTPX_ASYNC_CLIENT_WRAPPER
 from primary.utils.azure_monitor_setup import setup_azure_monitor_telemetry
 from primary.utils.exception_handlers import configure_service_level_exception_handlers
@@ -58,6 +62,9 @@
 
 LOGGER = logging.getLogger(__name__)
 
+# Setup Cosmos DB emulator database if running locally
+maybe_setup_local_database()
+
 
 def custom_generate_unique_id(route: APIRoute) -> str:
     return f"{route.name}"
@@ -106,6 +113,9 @@ async def shutdown_event_async() -> None:
 app.include_router(rft_router, prefix="/rft", tags=["rft"])
 app.include_router(vfp_router, prefix="/vfp", tags=["vfp"])
 app.include_router(dev_router, prefix="/dev", tags=["dev"], include_in_schema=False)
+app.include_router(sessions_router, prefix="/sessions", tags=["sessions"])
+app.include_router(snapshots_router, prefix="/snapshots", tags=["snapshots"])
+app.include_router(snapshot_preview_router, prefix="/snapshot-preview", tags=["snapshot_preview"])
 
 auth_helper = AuthHelper()
 app.include_router(auth_helper.router)
@@ -120,7 +130,7 @@ async def shutdown_event_async() -> None:
 
 # Add out custom middleware to enforce that user is logged in
 # Also redirects to /login endpoint for some select paths
-unprotected_paths = ["/logout", "/logged_in_user", "/alive", "/openapi.json"]
+unprotected_paths = ["/logout", "/logged_in_user", "/alive", "/openapi.json", "/snapshot-preview"]
 paths_redirected_to_login = ["/", "/alive_protected"]
 
 app.add_middleware(

backend_py/primary/primary/routers/general.py

@@ -15,6 +15,7 @@
 
 
 class UserInfo(BaseModel):
+    user_id: str
     username: str
     display_name: str | None = None
     avatar_b64str: str | None = None
@@ -63,6 +64,7 @@ async def get_logged_in_user(
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="No user is logged in")
 
     user_info = UserInfo(
+        user_id=authenticated_user.get_user_id(),
         username=authenticated_user.get_username(),
         avatar_b64str=None,
         display_name=None,

backend_py/primary/primary/routers/graph/router.py

@@ -1,36 +1,71 @@
 import logging
 
 import httpx
-from fastapi import APIRouter, Depends, Query
+from fastapi import APIRouter, Depends, Query, Path
 
 from primary.auth.auth_helper import AuthHelper
 from primary.services.utils.authenticated_user import AuthenticatedUser
 from primary.services.graph_access.graph_access import GraphApiAccess
+from primary.services.service_exceptions import Service, AuthorizationError, ServiceRequestError
 
-from .schemas import GraphUserPhoto
+
+from . import schemas
 
 LOGGER = logging.getLogger(__name__)
 
 router = APIRouter()
 
 
+@router.get("/user_info/{user_id_or_email}")
+async def get_user_info(
+    authenticated_user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
+    user_id_or_email: str = Path(description="User email, id or 'me' for the authenticated user"),
+) -> schemas.GraphUser | None:
+    if not authenticated_user.has_graph_access_token():
+        raise AuthorizationError("User can't access Graph API", Service.GENERAL)
+
+    graph_api_access = GraphApiAccess(authenticated_user.get_graph_access_token())
+
+    try:
+        user_info = await graph_api_access.get_user_info(user_id_or_email)
+
+        if not user_info:
+            return None
+
+        return schemas.GraphUser(
+            id=user_info["id"],
+            display_name=user_info["displayName"],
+            principal_name=user_info["userPrincipalName"],
+            email=user_info["mail"],
+        )
+
+    except httpx.HTTPError as exc:
+        raise ServiceRequestError(
+            "Error while fetching user from Microsoft Graph API (HTTP error)", Service.GENERAL
+        ) from exc
+    except httpx.InvalidURL as exc:
+        raise ServiceRequestError(
+            "Error while fetching user from Microsoft Graph API (HTTP error)", Service.GENERAL
+        ) from exc
+
+
 @router.get("/user_photo/")
 async def get_user_photo(
     # fmt:off
     authenticated_user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
-    user_email: str = Query(description="User email or 'me' for the authenticated user"),
+    user_id_or_email: str = Query(description="User email or 'me' for the authenticated user"),
     # fmt:on
-) -> GraphUserPhoto:
+) -> schemas.GraphUserPhoto:
     """Get username, display name and avatar from Microsoft Graph API for a given user email"""
 
-    user_photo = GraphUserPhoto(
+    user_photo = schemas.GraphUserPhoto(
         avatar_b64str=None,
     )
 
     if authenticated_user.has_graph_access_token():
         graph_api_access = GraphApiAccess(authenticated_user.get_graph_access_token())
         try:
-            avatar_b64str = await graph_api_access.get_user_profile_photo(user_email)
+            avatar_b64str = await graph_api_access.get_user_profile_photo(user_id_or_email)
 
             user_photo.avatar_b64str = avatar_b64str
         except httpx.HTTPError as exc:

backend_py/primary/primary/routers/graph/schemas.py

@@ -3,3 +3,10 @@
 
 class GraphUserPhoto(BaseModel):
     avatar_b64str: str | None = None
+
+
+class GraphUser(BaseModel):
+    id: str
+    principal_name: str
+    display_name: str
+    email: str

backend_py/primary/primary/routers/persistence/sessions/converters.py

@@ -0,0 +1,44 @@
+from primary.services.database_access.session_access.model import SessionDocument
+from primary.services.database_access.session_access.types import SessionMetadata
+from . import schemas
+
+
+def to_api_session_metadata_summary(session: SessionDocument) -> schemas.SessionMetadataWithId:
+    return schemas.SessionMetadataWithId(
+        id=session.id,
+        title=session.metadata.title,
+        description=session.metadata.description,
+        createdAt=session.metadata.created_at.isoformat(),
+        updatedAt=session.metadata.updated_at.isoformat(),
+        version=session.metadata.version,
+        hash=session.metadata.hash,
+    )
+
+
+def to_api_session_metadata(metadata: SessionMetadata) -> schemas.SessionMetadata:
+    return schemas.SessionMetadata(
+        title=metadata.title,
+        description=metadata.description,
+        createdAt=metadata.created_at.isoformat(),
+        updatedAt=metadata.updated_at.isoformat(),
+        version=metadata.version,
+        hash=metadata.hash,
+    )
+
+
+def to_api_session_record(document: SessionDocument) -> schemas.SessionDocument:
+    return schemas.SessionDocument(
+        id=document.id,
+        ownerId=document.owner_id,
+        metadata=to_api_session_metadata(document.metadata),
+        content=document.content,
+    )
+
+
+def to_api_session_index_page(
+    sessions: list[SessionDocument], continuation_token: str | None
+) -> schemas.SessionIndexPage:
+    return schemas.SessionIndexPage(
+        continuation_token=continuation_token,
+        items=[to_api_session_metadata_summary(session) for session in sessions],
+    )

backend_py/primary/primary/routers/persistence/sessions/router.py

@@ -0,0 +1,107 @@
+import logging
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from primary.middleware.add_browser_cache import no_cache
+from primary.services.database_access.session_access.session_access import SessionAccess
+from primary.services.database_access.query_collation_options import SortDirection
+from primary.auth.auth_helper import AuthHelper, AuthenticatedUser
+from primary.services.database_access.session_access.types import NewSession, SessionUpdate, SessionSortBy
+
+from . import schemas
+from .converters import (
+    to_api_session_metadata,
+    to_api_session_record,
+    to_api_session_index_page,
+)
+
+
+LOGGER = logging.getLogger(__name__)
+router = APIRouter()
+
+
+@router.get("/sessions", response_model=schemas.SessionIndexPage)
+@no_cache
+async def get_sessions_metadata(
+    user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
+    # ! Must be named "cursor" or "page" to make hey-api generate infinite-queries
+    # ! When we've updated to the latest hey-api version, we can change this to something custom
+    cursor: None | str = Query(None),
+    sort_by: Optional[SessionSortBy] = Query(None, description="Sort the result by"),
+    sort_direction: Optional[SortDirection] = Query(SortDirection.ASC, description="Sort direction: 'asc' or 'desc'"),
+    limit: int = Query(10, ge=1, le=100, description="Limit the number of results"),
+    # ? Is this becoming too many args? Should we make a post-search endpoint instead?
+    filter_title: Optional[str] = Query(None, description="Filter results by title (case insensitive)"),
+    filter_updated_from: Optional[str] = Query(None, description="Filter results by date"),
+    filter_updated_to: Optional[str] = Query(None, description="Filter results by date"),
+) -> schemas.SessionIndexPage:
+    access = SessionAccess.create(user.get_user_id())
+
+    async with access:
+        (items, cont_token) = await access.get_user_sessions_by_page_async(
+            continuation_token=cursor,
+            page_size=limit,
+            sort_by=sort_by,
+            sort_direction=sort_direction,
+            filter_title=filter_title,
+            filter_updated_from=filter_updated_from,
+            filter_updated_to=filter_updated_to,
+        )
+
+        return to_api_session_index_page(items, cont_token)
+
+
+@router.get("/sessions/{session_id}", response_model=schemas.SessionDocument)
+@no_cache
+async def get_session(
+    session_id: str, user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user)
+) -> schemas.SessionDocument:
+    access = SessionAccess.create(user.get_user_id())
+    async with access:
+        session = await access.get_session_by_id_async(session_id)
+        if not session:
+            raise HTTPException(status_code=404, detail="Session not found")
+        return to_api_session_record(session)
+
+
+@router.get("/sessions/metadata/{session_id}", response_model=schemas.SessionMetadata)
+@no_cache
+async def get_session_metadata(
+    session_id: str, user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user)
+) -> schemas.SessionMetadata:
+    access = SessionAccess.create(user.get_user_id())
+    async with access:
+        metadata = await access.get_session_metadata_async(session_id)
+        if not metadata:
+            raise HTTPException(status_code=404, detail="Session metadata not found")
+        return to_api_session_metadata(metadata)
+
+
+@router.post("/sessions", response_model=str)
+async def create_session(
+    session: NewSession, user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user)
+) -> str:
+    access = SessionAccess.create(user.get_user_id())
+    async with access:
+        session_id = await access.insert_session_async(session)
+        return session_id
+
+
+@router.put("/sessions/{session_id}", description="Updates a session object. Allows for partial update objects")
+async def update_session(
+    session_id: str,
+    session_update: SessionUpdate,
+    user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
+) -> schemas.SessionDocument:
+    access = SessionAccess.create(user.get_user_id())
+    async with access:
+        updated_session = await access.update_session_async(session_id, session_update)
+        return to_api_session_record(updated_session)
+
+
+@router.delete("/sessions/{session_id}")
+async def delete_session(session_id: str, user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user)) -> None:
+    access = SessionAccess.create(user.get_user_id())
+    async with access:
+        await access.delete_session_async(session_id)

backend_py/primary/primary/routers/persistence/sessions/schemas.py

@@ -0,0 +1,27 @@
+from typing import Optional
+from pydantic import BaseModel
+
+
+class SessionMetadata(BaseModel):
+    title: str
+    description: Optional[str]
+    createdAt: str
+    updatedAt: str
+    version: int
+    hash: str
+
+
+class SessionMetadataWithId(SessionMetadata):
+    id: str
+
+
+class SessionDocument(BaseModel):
+    id: str
+    ownerId: str
+    metadata: SessionMetadata
+    content: str
+
+
+class SessionIndexPage(BaseModel):
+    items: list[SessionMetadataWithId]
+    continuation_token: str | None