[Persistence]: Implement persistence for InplaceVolumesPlot

.vscode/tasks.json

@@ -1,12 +1,12 @@
 {
-    "version": "2.0.0",
-    "tasks": [
-        {
-            "type": "npm",
-            "script": "generate-api",
-            "path": "frontend",
-            "problemMatcher": [],
-            "label": "Generate frontend code from OpenAPI"
-        }
-    ]
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "npm",
+      "script": "generate:api",
+      "path": "frontend",
+      "problemMatcher": [],
+      "label": "Generate frontend code from OpenAPI"
+    }
+  ]
 }

README.md

@@ -44,7 +44,7 @@ e.g. typically when a new dependency is added, the relevant component needs to b
 All the content in `/frontend/src/api/autogen` is auto-generated using the defined endpoints
 in the Python backend. In order to update the auto-generated code you can either
 
-1. Run `npm run generate-api --prefix ./frontend`.
+1. Run `npm run generate:api --prefix ./frontend`.
 2. Use the VSCode tasks shortcut:
    a) `Ctrl + P` to open the command palette.
    b) Type `> Tasks` and enter to filter to commands only.

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/persistence/sessions/converters.py

@@ -0,0 +1,34 @@
+from primary.services.database_access.session_access.model import SessionDocument
+from primary.services.database_access.session_access.types import SessionMetadata, SessionMetadataWithId
+from . import schemas
+
+
+def to_api_session_metadata_summary(metadata: SessionMetadataWithId) -> schemas.SessionMetadataWithId:
+    return schemas.SessionMetadataWithId(
+        id=metadata.id,
+        title=metadata.title,
+        description=metadata.description,
+        createdAt=metadata.created_at.isoformat(),
+        updatedAt=metadata.updated_at.isoformat(),
+        version=metadata.version,
+    )
+
+
+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,
+    )

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

@@ -0,0 +1,88 @@
+import logging
+from typing import List, 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.auth.auth_helper import AuthHelper, AuthenticatedUser
+from primary.services.database_access.session_access.types import (
+    NewSession,
+    SessionUpdate,
+    SortBy,
+    SortDirection,
+)
+from primary.routers.persistence.sessions.converters import (
+    to_api_session_metadata_summary,
+    to_api_session_metadata,
+    to_api_session_record,
+)
+
+from . import schemas
+
+LOGGER = logging.getLogger(__name__)
+router = APIRouter()
+
+
+@router.get("/sessions", response_model=List[schemas.SessionMetadataWithId])
+@no_cache
+async def get_sessions_metadata(
+    user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
+    sort_by: Optional[SortBy] = Query(None, description="Sort the result by"),
+    sort_direction: Optional[SortDirection] = Query(SortDirection.ASC, description="Sort direction: 'asc' or 'desc'"),
+    limit: Optional[int] = Query(10, ge=1, le=100, description="Limit the number of results"),
+):
+    access = SessionAccess.create(user.get_user_id())
+    async with access:
+        items = await access.get_filtered_sessions_metadata_for_user_async(
+            sort_by=sort_by, sort_direction=sort_direction, limit=limit
+        )
+        return [to_api_session_metadata_summary(item) for item in items]
+
+
+@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)):
+    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)):
+    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)):
+    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}")
+async def update_session(
+    session_id: str,
+    session_update: SessionUpdate,
+    user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
+):
+    access = SessionAccess.create(user.get_user_id())
+    async with access:
+        await access.update_session_async(session_id, session_update)
+
+
+@router.delete("/sessions/{session_id}")
+async def delete_session(session_id: str, user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user)):
+    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 SessionMetadataWithId(BaseModel):
+    id: str
+    title: str
+    description: Optional[str]
+    createdAt: str
+    updatedAt: str
+    version: int
+
+
+class SessionMetadata(BaseModel):
+    title: str
+    description: Optional[str]
+    createdAt: str
+    updatedAt: str
+    version: int
+    hash: str
+
+
+class SessionDocument(BaseModel):
+    id: str
+    ownerId: str
+    metadata: SessionMetadata
+    content: str

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

@@ -0,0 +1,44 @@
+import html
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import HTMLResponse
+
+from primary.services.database_access.snapshot_access.snapshot_access import SnapshotAccess
+
+router = APIRouter()
+
+
+@router.get("/{snapshot_id}", response_class=HTMLResponse)
+async def snapshot_preview(snapshot_id: str, request: Request):
+    access = await SnapshotAccess.create("")
+    async with access:
+        metadata = await access.get_snapshot_metadata(snapshot_id)
+        if not metadata:
+            raise HTTPException(status_code=404, detail="Snapshot metadata not found")
+
+        base_url = get_external_base_url(request)
+        snapshot_url = f"{base_url}/snapshot/{snapshot_id}"
+
+        title = html.escape(metadata.title)
+        description = html.escape(metadata.description or "No description available")
+
+        return f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+        <meta charset="utf-8" />
+        <meta property="og:title" content="{title}" />
+        <meta property="og:description" content="{description}" />
+        <meta property="og:url" content="{snapshot_url}" />
+        <meta property="og:type" content="website" />
+        </head>
+        <body>
+        Redirecting… <script>window.location = "{snapshot_url}";</script>
+        </body>
+        </html>
+        """
+
+
+def get_external_base_url(request: Request) -> str:
+    forwarded_proto = request.headers.get("x-forwarded-proto", "http")
+    forwarded_host = request.headers.get("x-forwarded-host", request.headers.get("host", "localhost"))
+    return f"{forwarded_proto}://{forwarded_host}"

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

@@ -0,0 +1,46 @@
+from primary.services.database_access.snapshot_access.models import SnapshotAccessLog
+from primary.services.database_access.snapshot_access.types import Snapshot, SnapshotMetadata, SnapshotMetadataWithId
+
+from . import schemas
+
+
+def to_api_snapshot_metadata_summary(metadata: SnapshotMetadataWithId) -> schemas.SnapshotMetadataWithId:
+    return schemas.SnapshotMetadataWithId(
+        id=metadata.id,
+        ownerId=metadata.owner_id,
+        title=metadata.title,
+        description=metadata.description,
+        createdAt=metadata.created_at.isoformat(),
+        updatedAt=metadata.updated_at.isoformat(),
+        hash=metadata.hash,
+    )
+
+
+def to_api_snapshot_metadata(metadata: SnapshotMetadata) -> schemas.SnapshotMetadata:
+    return schemas.SnapshotMetadata(
+        ownerId=metadata.owner_id,
+        title=metadata.title,
+        description=metadata.description,
+        createdAt=metadata.created_at.isoformat(),
+        updatedAt=metadata.updated_at.isoformat(),
+        hash=metadata.hash,
+    )
+
+
+def to_api_snapshot(snapshot: Snapshot) -> schemas.Snapshot:
+    return schemas.Snapshot(
+        id=snapshot.id,
+        metadata=to_api_snapshot_metadata(snapshot.metadata),
+        content=snapshot.content,
+    )
+
+
+def to_api_snapshot_access_log(access_log: SnapshotAccessLog, metadata: SnapshotMetadata) -> schemas.SnapshotAccessLog:
+    return schemas.SnapshotAccessLog(
+        visitorId=access_log.visitor_id,
+        snapshotId=access_log.snapshot_id,
+        visits=access_log.visits,
+        firstVisitedAt=access_log.first_visited_at.isoformat() if access_log.first_visited_at else None,
+        lastVisitedAt=access_log.last_visited_at.isoformat() if access_log.last_visited_at else None,
+        snapshotMetadata=to_api_snapshot_metadata(metadata),
+    )