Websockets

src/unipoll_api/account_manager.py

@@ -80,4 +80,4 @@ def get_database_strategy(access_token_db=Depends(get_access_token_db)) -> Datab
 fastapi_users = FastAPIUsers[Account, PydanticObjectId](get_user_manager, [jwt_backend, cookie_backend])  # type: ignore
 
 get_current_active_user = fastapi_users.current_user(active=True)
-active_user: ContextVar = ContextVar("active_user")
+active_user: ContextVar[Account] = ContextVar("active_user")

src/unipoll_api/actions/__init__.py

@@ -6,3 +6,4 @@
 from . import workspace as WorkspaceActions  # noqa: F401
 from . import permissions as PermissionsActions  # noqa: F401
 from . import members as MembersActions  # noqa: F401
+from . import websocket as WebsocketActions  # noqa: F401

src/unipoll_api/actions/members.py

@@ -8,7 +8,8 @@
 from unipoll_api.dependencies import get_member
 
 
-async def get_members(resource: Workspace | Group, check_permissions: bool = True) -> MemberSchemas.MemberList:
+async def get_members(resource: Workspace | Group,
+                      check_permissions: bool = True) -> MemberSchemas.MemberList:
     # Check if the user has permission to add members
     await Permissions.check_permissions(resource, "get_members", check_permissions)
 

src/unipoll_api/actions/poll.py

@@ -33,7 +33,7 @@ async def create_poll(workspace: Workspace,
                       input_data: PollSchemas.CreatePollRequest,
                       check_permissions: bool = True) -> PollSchemas.PollResponse:
     # Check if the user has permission to create polls
-    await Permissions.check_permissions(actions, "create_polls", check_permissions)
+    await Permissions.check_permissions(workspace, "create_polls", check_permissions)
 
     # Check if poll name is unique
     poll: Poll  # For type hinting, until Link type is supported

src/unipoll_api/actions/websocket.py

@@ -0,0 +1,94 @@
+from typing import Literal
+from unipoll_api import dependencies
+from . import WorkspaceActions, GroupActions, MembersActions, PolicyActions
+from unipoll_api.schemas import WorkspaceSchemas, GroupSchemas, MemberSchemas
+from unipoll_api.documents import ResourceID
+from unipoll_api.exceptions.resource import APIException
+
+
+# Workspace actions
+
+
+async def get_workspaces():
+    return await WorkspaceActions.get_workspaces()
+
+
+async def create_workspace(name: str, description: str = ""):
+    data = WorkspaceSchemas.WorkspaceCreateInput(name=name, description=description)
+    return await WorkspaceActions.create_workspace(data)
+
+
+async def get_workspace_info(workspace_id: ResourceID):
+    workspace = await dependencies.get_workspace(workspace_id)
+    return await WorkspaceActions.get_workspace(workspace, **args)
+
+
+async def update_workspace_info(workspace_id: ResourceID, name: str, description: str = ""):
+    workspace = await dependencies.get_workspace(workspace_id)
+    data = WorkspaceSchemas.WorkspaceUpdateRequest(name=name, description=description)
+    return await WorkspaceActions.update_workspace(workspace, data)
+
+
+async def delete_workspace(workspace_id: ResourceID):
+    workspace = await dependencies.get_workspace(workspace_id)
+    return await WorkspaceActions.delete_workspace(workspace)
+
+
+async def get_workspace_members(workspace_id: ResourceID):
+    workspace = await dependencies.get_workspace(workspace_id)
+    return await MembersActions.get_members(workspace)
+
+
+async def add_workspace_members(workspace_id: ResourceID, account_id_list: list[ResourceID]):
+    workspace = await dependencies.get_workspace(workspace_id)
+    return await MembersActions.add_members(workspace, account_id_list)
+
+
+async def get_workspace_policies(workspace_id: ResourceID):
+    workspace = await dependencies.get_workspace(workspace_id)
+    return await PolicyActions.get_policies(resource=workspace)
+
+
+# Group actions
+
+
+async def get_groups(workspace_id: ResourceID):
+    workspace = await dependencies.get_workspace(workspace_id)
+    return await GroupActions.get_groups(workspace)
+
+
+async def create_group(workspace_id: ResourceID, name: str, description: str = ""):
+    workspace = await dependencies.get_workspace(workspace_id)
+    # data = GroupSchemas.GroupCreateInput(name=name, description=description)
+    return await GroupActions.create_group(workspace, name, description)
+
+
+async def get_group_info(group_id: ResourceID):
+    group = await dependencies.get_group(group_id)
+    return await GroupActions.get_group(group)
+
+
+async def update_group_info(group_id: ResourceID, name: str, description: str = ""):
+    group = await dependencies.get_group(group_id)
+    data = GroupSchemas.GroupUpdateRequest(name=name, description=description)
+    return await GroupActions.update_group(group, data)
+
+
+async def delete_group(group_id: ResourceID):
+    group = await dependencies.get_group(group_id)
+    return await GroupActions.delete_group(group)
+
+
+async def get_group_members(group_id: ResourceID):
+    group = await dependencies.get_group(group_id)
+    return await MembersActions.get_members(group)
+
+
+async def add_group_members(group_id: ResourceID, account_id_list: list[ResourceID]):
+    group = await dependencies.get_group(group_id)
+    return await MembersActions.add_members(group, account_id_list)
+
+
+async def get_group_policies(group_id: ResourceID):
+    group = await dependencies.get_group(group_id)
+    return await PolicyActions.get_policies(resource=group)

src/unipoll_api/app.py

@@ -6,7 +6,8 @@
 from fastapi.routing import APIRoute
 from fastapi.middleware.cors import CORSMiddleware
 from beanie import init_beanie
-from unipoll_api.routes import router
+# from unipoll_api.routes import router, websocket
+from unipoll_api.routes import create_router
 from unipoll_api.mongo_db import mainDB, documentModels
 from unipoll_api.config import get_settings
 from unipoll_api.__version__ import version
@@ -18,13 +19,16 @@
 
 # Create FastAPI application
 app = FastAPI(
+    docs_url=None,                         # Disable default docs
+    redoc_url=None,                        # Disable default redoc
     title=settings.app_name,               # Title of the application
     description=settings.app_description,  # Description of the application
     version=settings.app_version,          # Version of the application
 )
 
+
 # Add endpoints defined in the routes directory
-app.include_router(router)
+app.include_router(create_router(app, 2))  # Set default API version to 2
 
 # Add CORS middleware to allow cross-origin requests
 origins = settings.origins.split(",")

src/unipoll_api/dependencies.py

@@ -1,10 +1,12 @@
 from typing import Annotated
 from functools import wraps
 # from bson import DBRef
-from fastapi import Cookie, Depends, Query, HTTPException, WebSocket
+from fastapi import Cookie, Depends, Query, HTTPException
 from unipoll_api.account_manager import active_user, get_current_active_user
 from unipoll_api.documents import ResourceID, Workspace, Group, Account, Poll, Policy, Member
 from unipoll_api import exceptions as Exceptions
+from unipoll_api.account_manager import get_access_token_db, get_database_strategy
+from datetime import timedelta, timezone, datetime
 
 
 # Wrapper to handle exceptions and raise HTTPException
@@ -41,10 +43,18 @@ async def get_member(account: Account, resource: Workspace | Group) -> Member:
     raise Exceptions.ResourceExceptions.ResourceNotFound("member", account.id)
 
 
-async def websocket_auth(websocket: WebSocket,
-                         session: Annotated[str | None, Cookie()] = None,
-                         token: Annotated[str | None, Query()] = None) -> dict:
-    return {"cookie": session, "token": token}
+async def websocket_auth(session: Annotated[str | None, Cookie()] = None,
+                         token: Annotated[str | None, Query()] = None,
+                         token_db=Depends(get_access_token_db),
+                         strategy=Depends(get_database_strategy)
+                         ) -> Account:
+    user = None
+    if token:
+        max_age = datetime.now(timezone.utc) - timedelta(seconds=strategy.lifetime_seconds)
+        token_data = await token_db.get_by_token(token, max_age)
+        if token_data:
+            user = await Account.get(token_data.user_id)
+    return user
 
 
 # Dependency for getting a workspace with the given id

src/unipoll_api/exceptions/__init__.py

@@ -5,3 +5,4 @@
 from . import poll as PollExceptions  # noqa: F401
 from . import resource as ResourceExceptions  # noqa: F401
 from . import workspace as WorkspaceExceptions  # noqa: F401
+from . import websocket as WebSocketExceptions  # noqa: F401

src/unipoll_api/exceptions/websocket.py

@@ -0,0 +1,29 @@
+from fastapi import status
+from unipoll_api.exceptions.resource import APIException
+
+
+class AuthenticationError(APIException):
+    def __init__(self):
+        super().__init__(code=status.WS_1008_POLICY_VIOLATION,
+                         detail="Invalid access token or authorization header")
+
+
+class InvalidAction(APIException):
+    def __init__(self, action: str):
+        super().__init__(code=status.WS_1003_UNSUPPORTED_DATA,
+                         detail=f'Action "{action}" not found')
+
+
+class InvalidMessageData(APIException):
+    def __init__(self, action: str, valid_args: list[str], data: list[str]):
+        super().__init__(code=status.WS_1003_UNSUPPORTED_DATA,
+                         detail=f'Invalid data for action "{action}".' +
+                                f'Valid arguments are: {valid_args}.' +
+                                f'You provided: {data}')
+
+
+class ActionMissingRequiredArgs(APIException):
+    def __init__(self, action: str, required_args: list[str], provided_args: list[str]):
+        super().__init__(code=status.WS_1003_UNSUPPORTED_DATA,
+                         detail=f"The action '{action}' requires arguments: {required_args}. " +
+                                f"You provided: {provided_args}")

src/unipoll_api/routes/__init__.py

@@ -1,48 +1,50 @@
-from fastapi import APIRouter, Depends
-from unipoll_api.dependencies import set_active_user
-
-# Impport endpoints defined in the routes directory
-from . import account as AccountRoutes
-from . import authentication as AuthenticationRoutes
-from . import group as GroupRoutes
-from . import poll as PollRoutes
-from . import websocket as WebSocketRoutes
-from . import workspace as WorkspaceRoutes
-
-# Create main router
-router: APIRouter = APIRouter()
-
-# Add endpoints defined in the routes directory
-router.include_router(WorkspaceRoutes.open_router,
-                      prefix="/workspaces",
-                      tags=["Workspaces"],
-                      dependencies=[Depends(set_active_user)])
-router.include_router(WorkspaceRoutes.router,
-                      prefix="/workspaces",
-                      tags=["Workspaces"],
-                      dependencies=[Depends(set_active_user)])
-router.include_router(GroupRoutes.open_router,
-                      prefix="/groups",
-                      tags=["Groups"],
-                      dependencies=[Depends(set_active_user)])
-router.include_router(GroupRoutes.router,
-                      prefix="/groups",
-                      tags=["Groups"],
-                      dependencies=[Depends(set_active_user)])
-router.include_router(PollRoutes.router,
-                      prefix="/polls",
-                      tags=["Polls"],
-                      dependencies=[Depends(set_active_user)])
-router.include_router(WebSocketRoutes.router,
-                      prefix="/ws",
-                      tags=["WebSocket"])
-router.include_router(AccountRoutes.router,
-                      prefix="/accounts",
-                      tags=["Accounts"],
-                      dependencies=[Depends(set_active_user)])
-router.include_router(AuthenticationRoutes.router,
-                      prefix="/auth",
-                      tags=["Authentication"])
-router.include_router(WebSocketRoutes.router,
-                      prefix="/ws",
-                      tags=["WebSocket"])
+from fastapi import APIRouter
+from fastapi.routing import APIRoute
+from unipoll_api.utils import api_versioning
+from .v1 import router as v1_router
+from .v2 import router as v2_router
+from .swagger_docs import create_doc_router
+from .websocket import router as websocket_router
+
+
+# Function to generate unique operation IDs for different API versions
+def generate_unique_id(version: int):
+    def func(route: APIRoute):
+        return f"api-v{version}-{route.tags[0]}-{route.name}"
+    return func
+
+
+# Function to create API Router
+def create_router(app, default_version):
+    # API Router that contains all of the endpoints
+    router = APIRouter()
+
+    # Dictionary of endpoints for each version of the API
+    endpoints = {
+        1: v1_router,
+        2: v2_router,
+    }
+
+    # Default API version
+    router.include_router(endpoints[default_version])
+    router.include_router(websocket_router, prefix="/ws", tags=["WebSocket"])
+
+    # Add API v1 endpoints to the main router
+    router.include_router(v1_router,
+                          prefix="/v1",
+                          generate_unique_id_function=generate_unique_id(1))
+    # Add API v1 OpenAPI schemas for documentation
+    api_versioning.add_api(v1_router, version=1)
+
+    # Add API v2 endpoints to the main router
+    router.include_router(v2_router,
+                          prefix="/v2",
+                          generate_unique_id_function=generate_unique_id(2))
+    # Add API v2 OpenAPI schemas for documentation
+    api_versioning.add_api(v2_router, version=2)
+
+    # Swagger Documentation Endpoints
+    router.include_router(create_doc_router(app, default_version))
+
+    # Return the main router
+    return router

src/unipoll_api/routes/swagger_docs.py

@@ -0,0 +1,63 @@
+from fastapi import APIRouter
+from fastapi.openapi.docs import (
+    get_redoc_html,
+    get_swagger_ui_html,
+    get_swagger_ui_oauth2_redirect_html,
+)
+from unipoll_api.utils import api_versioning
+
+
+# Function to create router for documentation endpoints
+def create_doc_router(app, default_version):
+    # Router for documentation endpoints
+    doc_router = APIRouter()
+
+    @doc_router.get("/v{version}/openapi.json", include_in_schema=False)
+    async def get_openapi_schema(version: int):
+        return api_versioning.openapi_schemas[version]
+
+    # Default Docs
+    @doc_router.get("/docs", include_in_schema=False)
+    async def default_swagger_ui_html():
+        return get_swagger_ui_html(
+            openapi_url=f"/v{default_version}/openapi.json",
+            title=app.title + " - Swagger UI",
+            oauth2_redirect_url=app.swagger_ui_oauth2_redirect_url,
+            swagger_js_url="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js",
+            swagger_css_url="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css",
+        )
+
+    # Versioned Docs
+    @doc_router.get("/v{version}/docs", include_in_schema=False)
+    async def versioned_swagger_ui_html(version: int):
+        return get_swagger_ui_html(
+            openapi_url=f"/v{version}/openapi.json",
+            title=app.title + " - Swagger UI",
+            oauth2_redirect_url=app.swagger_ui_oauth2_redirect_url,
+            swagger_js_url="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js",
+            swagger_css_url="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css",
+        )
+
+    @doc_router.get(app.swagger_ui_oauth2_redirect_url, include_in_schema=False)
+    async def swagger_ui_redirect():
+        return get_swagger_ui_oauth2_redirect_html()
+
+    # Default ReDoc
+    @doc_router.get("/redoc", include_in_schema=False)
+    async def default_redoc_html():
+        return get_redoc_html(
+            openapi_url=f"/v{default_version}/openapi.json",
+            title=app.title + " - ReDoc",
+            redoc_js_url="https://unpkg.com/redoc@next/bundles/redoc.standalone.js",
+        )
+
+    # Versioned ReDoc
+    @doc_router.get("/v{version}/redoc", include_in_schema=False)
+    async def versioned_redoc_html(version: int):
+        return get_redoc_html(
+            openapi_url=f"/v{version}/openapi.json",
+            title=app.title + " - ReDoc",
+            redoc_js_url="https://unpkg.com/redoc@next/bundles/redoc.standalone.js",
+        )
+
+    return doc_router