146 lines
5.5 KiB
Python
146 lines
5.5 KiB
Python
"""Workspace service: creation, membership, invitation token flow.
|
|
|
|
Invitation security contract:
|
|
- The service generates a random 32-byte token.
|
|
- Only SHA-256(token) is persisted (token_hash).
|
|
- The raw token is returned to the caller exactly once and never stored.
|
|
- Redemption: hash(presented_token) must match stored token_hash.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import secrets
|
|
from datetime import datetime, timedelta
|
|
from uuid import UUID, uuid4
|
|
|
|
from app.entities.personal_data import PersonalData
|
|
from app.entities.workspace import Workspace
|
|
from app.entities.workspace_invitation import WorkspaceInvitation
|
|
from app.repositories.personal_data_repository import PersonalDataRepository
|
|
from app.repositories.workspace_repository import (
|
|
WorkspaceInvitationRepository,
|
|
WorkspaceRepository,
|
|
)
|
|
from app.utils.errors import InvitationError, NotFoundError, ValidationError
|
|
|
|
_INVITE_TTL_HOURS = 72
|
|
|
|
|
|
class WorkspaceService:
|
|
def __init__(
|
|
self,
|
|
ws_repo: WorkspaceRepository,
|
|
inv_repo: WorkspaceInvitationRepository,
|
|
pd_repo: PersonalDataRepository,
|
|
) -> None:
|
|
self._ws = ws_repo
|
|
self._inv = inv_repo
|
|
self._pd = pd_repo
|
|
|
|
# ------------------------------------------------------------------
|
|
# Workspace CRUD
|
|
# ------------------------------------------------------------------
|
|
|
|
async def create_workspace(self, name: str) -> Workspace:
|
|
ws = Workspace(id=uuid4(), name=name, created_at=datetime.now())
|
|
return await self._ws.create(ws)
|
|
|
|
async def get_workspace(self, workspace_id: UUID) -> Workspace:
|
|
ws = await self._ws.get_by_id(workspace_id)
|
|
if ws is None:
|
|
raise NotFoundError(f"Workspace {workspace_id} not found")
|
|
return ws
|
|
|
|
async def update_workspace(
|
|
self, workspace_id: UUID, name: str | None = None, planning_goal: str | None = None
|
|
) -> Workspace:
|
|
ws = await self.get_workspace(workspace_id)
|
|
if name is not None:
|
|
ws.name = name
|
|
if planning_goal is not None:
|
|
valid = {"max_time", "max_money", "balanced"}
|
|
if planning_goal not in valid:
|
|
raise ValidationError(f"planning_goal must be one of {valid}")
|
|
ws.planning_goal = planning_goal
|
|
return await self._ws.update(workspace_id, ws)
|
|
|
|
async def list_members(self, workspace_id: UUID) -> list[PersonalData]:
|
|
"""Return all (non-deleted) parent profiles in the workspace."""
|
|
return await self._pd.list_by_workspace(workspace_id)
|
|
|
|
async def add_placeholder_parent(self, workspace_id: UUID, display_name: str) -> PersonalData:
|
|
"""Create a parent profile without a login (solo planning for a partner)."""
|
|
await self.get_workspace(workspace_id) # verify workspace exists
|
|
pd = PersonalData(
|
|
uuid=uuid4(),
|
|
workspace_id=workspace_id,
|
|
name=display_name,
|
|
created_at=datetime.now(),
|
|
)
|
|
return await self._pd.create(pd)
|
|
|
|
# ------------------------------------------------------------------
|
|
# Invitation flow
|
|
# ------------------------------------------------------------------
|
|
|
|
async def invite_partner(self, workspace_id: UUID, invited_by_user_id: UUID) -> str:
|
|
"""Generate a single-use invite token. Returns the RAW token (share out-of-band).
|
|
|
|
Only the SHA-256 hash is stored. The raw token is lost after this call.
|
|
"""
|
|
await self.get_workspace(workspace_id)
|
|
raw_token = secrets.token_urlsafe(32)
|
|
token_hash = _sha256(raw_token)
|
|
invitation = WorkspaceInvitation(
|
|
id=uuid4(),
|
|
workspace_id=workspace_id,
|
|
token_hash=token_hash,
|
|
invited_by_user_id=invited_by_user_id,
|
|
status="pending",
|
|
expires_at=datetime.now() + timedelta(hours=_INVITE_TTL_HOURS),
|
|
created_at=datetime.now(),
|
|
)
|
|
await self._inv.create(invitation)
|
|
return raw_token
|
|
|
|
async def redeem_invitation(
|
|
self, raw_token: str, personal_data_uuid: UUID
|
|
) -> WorkspaceInvitation:
|
|
"""Link personal_data to the workspace and mark invitation accepted."""
|
|
token_hash = _sha256(raw_token)
|
|
inv = await self._inv.get_by_token_hash(token_hash)
|
|
|
|
if inv is None:
|
|
raise InvitationError("Invitation not found")
|
|
if inv.status != "pending":
|
|
raise InvitationError(f"Invitation is {inv.status}")
|
|
if datetime.now() > inv.expires_at:
|
|
inv.status = "expired"
|
|
await self._inv.update(inv.id, inv)
|
|
raise InvitationError("Invitation has expired")
|
|
|
|
# Link the personal_data to the workspace.
|
|
pd = await self._pd.get_by_id(personal_data_uuid)
|
|
if pd is None:
|
|
raise NotFoundError(f"PersonalData {personal_data_uuid} not found")
|
|
pd.workspace_id = inv.workspace_id
|
|
await self._pd.update(pd.uuid, pd)
|
|
|
|
inv.status = "accepted"
|
|
inv.accepted_at = datetime.now()
|
|
return await self._inv.update(inv.id, inv)
|
|
|
|
async def revoke_invitation(self, invitation_id: UUID) -> None:
|
|
inv = await self._inv.get_by_id(invitation_id)
|
|
if inv is None:
|
|
raise NotFoundError(f"Invitation {invitation_id} not found")
|
|
if inv.status != "pending":
|
|
raise ValidationError(f"Cannot revoke a {inv.status} invitation")
|
|
inv.status = "revoked"
|
|
await self._inv.update(inv.id, inv)
|
|
|
|
|
|
def _sha256(value: str) -> str:
|
|
return hashlib.sha256(value.encode()).hexdigest()
|