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,
},
}