Newer
Older
gnexus-book / server / app / storage / ownership.py
from __future__ import annotations

import json
from pathlib import Path
from typing import Any

from sqlalchemy import func, select, update

from .db import Database
from .models import AuditLog, Document, InventoryItem, User, utcnow


def assign_owner(
    database: Database,
    *,
    sub: str,
    email: str | None = None,
    display_name: str | None = None,
    system_role: str | None = None,
    status: str | None = None,
    profile: dict[str, Any] | None = None,
    all_data: bool = False,
) -> dict[str, Any]:
    """Create or update the owner mirror and assign unowned data to it."""
    if not sub:
        raise ValueError("sub is required")

    with database.session() as session:
        with session.begin():
            user = session.scalars(select(User).where(User.sub == sub)).first()
            if user is None:
                user = User(
                    sub=sub,
                    email=email,
                    display_name=display_name or email or sub,
                    profile=dict(profile or {}),
                    system_role=system_role,
                    status=status,
                )
                session.add(user)
            else:
                if email:
                    user.email = email
                if display_name:
                    user.display_name = display_name
                if profile is not None:
                    user.profile = dict(profile)
                if system_role:
                    user.system_role = system_role
                if status:
                    user.status = status
                user.updated_at = utcnow()
            session.flush()

            document_query = update(Document).values(owner_user_id=user.id)
            inventory_query = update(InventoryItem).values(owner_user_id=user.id)
            if not all_data:
                document_query = document_query.where(Document.owner_user_id.is_(None))
                inventory_query = inventory_query.where(
                    InventoryItem.owner_user_id.is_(None)
                )

            documents = session.execute(document_query).rowcount or 0
            inventory_items = session.execute(inventory_query).rowcount or 0
            counts = {
                "documents": documents,
                "inventory_items": inventory_items,
            }

            if documents or inventory_items:
                session.add(
                    AuditLog(
                        actor_user_id=user.id,
                        actor_kind="user",
                        actor_name=user.display_name or user.email or user.sub,
                        via="cli",
                        action="ownership.assigned",
                        entity_type="repository",
                        entity_id=sub,
                        after=counts,
                    )
                )

            return {
                "user_id": str(user.id),
                "sub": user.sub,
                **counts,
            }


def assign_owner_from_json(
    database: Database, path: str | Path, all_data: bool = False
) -> dict[str, Any]:
    payload = json.loads(Path(path).read_text(encoding="utf-8"))
    profile = payload.get("profile") or {}
    return assign_owner(
        database,
        sub=str(payload["sub"]),
        email=payload.get("email"),
        display_name=profile.get("display_name")
        or profile.get("username")
        or payload.get("email"),
        system_role=payload.get("system_role"),
        status=payload.get("status"),
        profile=profile,
        all_data=all_data,
    )


def ownership_counts(database: Database) -> dict[str, dict[str, int]]:
    with database.session() as session:
        return {
            "documents": {
                "owned": session.scalar(
                    select(func.count())
                    .select_from(Document)
                    .where(Document.owner_user_id.is_not(None))
                )
                or 0,
                "unowned": session.scalar(
                    select(func.count())
                    .select_from(Document)
                    .where(Document.owner_user_id.is_(None))
                )
                or 0,
            },
            "inventory_items": {
                "owned": session.scalar(
                    select(func.count())
                    .select_from(InventoryItem)
                    .where(InventoryItem.owner_user_id.is_not(None))
                )
                or 0,
                "unowned": session.scalar(
                    select(func.count())
                    .select_from(InventoryItem)
                    .where(InventoryItem.owner_user_id.is_(None))
                )
                or 0,
            },
        }