trex/portfolio-hub
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add admin user management

Browse Source
This commit is contained in:
genichin
2026-04-03 12:23:44 +00:00
parent 3d37186fa7
commit 5168e52e4b
18 changed files with 989 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/api/users.py
+75
View File
@@ -0,0 +1,75 @@
"""User management API routes."""
from __future__ import annotations
from typing import NoReturn
from fastapi import APIRouter, Depends, HTTPException, Response, status
from app.core.auth import require_admin
from app.domain.models import User
from app.schemas.user import CreateUserRequest, UpdateUserRequest, UserResponse
from app.services.user_service import UserService, get_user_service
router = APIRouter(prefix="/users", tags=["users"])
def _to_user_response(user: User) -> UserResponse:
return UserResponse(
id=user.id,
username=user.username,
email=user.email,
created_at=user.created_at,
updated_at=user.updated_at,
)
def _raise_user_error(exc: ValueError) -> NoReturn:
detail = str(exc)
if "찾을 수 없습니다" in detail:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=detail) from exc
if "이미 존재" in detail:
raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=detail) from exc
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=detail) from exc
@router.get("", response_model=list[UserResponse], dependencies=[Depends(require_admin)])
def list_users(service: UserService = Depends(get_user_service)) -> list[UserResponse]:
return [_to_user_response(user) for user in service.list()]
@router.get("/{user_id}", response_model=UserResponse, dependencies=[Depends(require_admin)])
def get_user(user_id: str, service: UserService = Depends(get_user_service)) -> UserResponse:
try:
return _to_user_response(service.get(user_id))
except ValueError as exc:
_raise_user_error(exc)
@router.post("", response_model=UserResponse, status_code=status.HTTP_201_CREATED, dependencies=[Depends(require_admin)])
def create_user(payload: CreateUserRequest, service: UserService = Depends(get_user_service)) -> UserResponse:
try:
return _to_user_response(service.create(payload))
except ValueError as exc:
_raise_user_error(exc)
@router.patch("/{user_id}", response_model=UserResponse, dependencies=[Depends(require_admin)])
def update_user(
user_id: str,
payload: UpdateUserRequest,
service: UserService = Depends(get_user_service),
) -> UserResponse:
try:
return _to_user_response(service.update(user_id, payload))
except ValueError as exc:
_raise_user_error(exc)
@router.delete("/{user_id}", status_code=status.HTTP_204_NO_CONTENT, dependencies=[Depends(require_admin)])
def delete_user(user_id: str, service: UserService = Depends(get_user_service)) -> Response:
try:
service.delete(user_id)
except ValueError as exc:
_raise_user_error(exc)
return Response(status_code=status.HTTP_204_NO_CONTENT)
app/cli/commands/user.py
+98
View File
@@ -0,0 +1,98 @@
"""User CLI commands."""
from __future__ import annotations
import typer
from app.cli.core.utils import execute_command, render_output
from app.cli.commands.portfolio import _confirm
from app.schemas.user import CreateUserRequest, UpdateUserRequest, UserResponse
from app.services.user_service import UserService
user_app = typer.Typer(help="User management commands.")
def _with_service(ctx: typer.Context, callback):
app_context = ctx.obj
repository = app_context.repository_factory(app_context.settings)
service = UserService(repository)
try:
return execute_command(app_context.console, callback=lambda: callback(service, app_context))
finally:
if hasattr(repository, "close"):
repository.close()
def _to_user_response(user) -> UserResponse:
return UserResponse(
id=user.id,
username=user.username,
email=user.email,
created_at=user.created_at,
updated_at=user.updated_at,
)
@user_app.command("list")
def list_users(ctx: typer.Context) -> None:
users = _with_service(ctx, lambda service, app_context: [_to_user_response(user) for user in service.list()])
render_output(ctx.obj.console, ctx.obj.output_format, users, empty_message="No users found.")
@user_app.command("get")
def get_user(
ctx: typer.Context,
user_id: str = typer.Argument(..., help="User identifier."),
) -> None:
user = _with_service(ctx, lambda service, app_context: _to_user_response(service.get(user_id)))
render_output(ctx.obj.console, ctx.obj.output_format, user)
@user_app.command("create")
def create_user(
ctx: typer.Context,
username: str = typer.Option(..., help="Username."),
email: str | None = typer.Option(None, help="Email address."),
force: bool = typer.Option(False, "--force", help="Skip confirmation prompt."),
) -> None:
_confirm(force, f"Create user {username}?")
user = _with_service(
ctx,
lambda service, app_context: _to_user_response(
service.create(CreateUserRequest(username=username, email=email))
),
)
render_output(ctx.obj.console, ctx.obj.output_format, user)
@user_app.command("update")
def update_user(
ctx: typer.Context,
user_id: str = typer.Argument(..., help="User identifier."),
username: str | None = typer.Option(None, help="New username."),
email: str | None = typer.Option(None, help="New email address."),
force: bool = typer.Option(False, "--force", help="Skip confirmation prompt."),
) -> None:
_confirm(force, f"Update user {user_id}?")
user = _with_service(
ctx,
lambda service, app_context: _to_user_response(
service.update(user_id, UpdateUserRequest(username=username, email=email))
),
)
render_output(ctx.obj.console, ctx.obj.output_format, user)
@user_app.command("delete")
def delete_user(
ctx: typer.Context,
user_id: str = typer.Argument(..., help="User identifier."),
force: bool = typer.Option(False, "--force", help="Skip confirmation prompt."),
) -> None:
_confirm(force, f"Delete user {user_id}?")
_with_service(ctx, lambda service, app_context: service.delete(user_id))
if ctx.obj.output_format == "json":
render_output(ctx.obj.console, ctx.obj.output_format, {"deleted": user_id})
else:
ctx.obj.console.print(f"Deleted user: {user_id}")
app/cli/core/utils.py
+46 -1
View File
@@ -14,6 +14,7 @@ from rich.table import Table
from app.core.errors import FeatureNotReadyError
from app.schemas.portfolio import PortfolioDetailResponse, PortfolioListItem
from app.schemas.user import UserResponse
T = TypeVar("T")
@@ -126,6 +127,41 @@ def print_portfolio_detail(console: Console, detail: PortfolioDetailResponse) ->
console.print(ledger_table)
def print_user_table(console: Console, users: list[UserResponse]) -> None:
table = Table(title="Users", expand=True)
table.add_column("ID", style="cyan", no_wrap=True)
table.add_column("Username", no_wrap=True)
table.add_column("Email")
table.add_column("Created At", no_wrap=True)
table.add_column("Updated At", no_wrap=True)
for user in users:
table.add_row(
user.id,
user.username,
user.email or "N/A",
user.created_at.isoformat(timespec="seconds") if user.created_at else "N/A",
user.updated_at.isoformat(timespec="seconds") if user.updated_at else "N/A",
)
console.print(table)
def print_user_detail(console: Console, user: UserResponse) -> None:
console.print(
Panel.fit(
"\n".join(
[
f"id: {user.id}",
f"username: {user.username}",
f"email: {user.email or 'N/A'}",
f"created_at: {user.created_at.isoformat(timespec='seconds') if user.created_at else 'N/A'}",
f"updated_at: {user.updated_at.isoformat(timespec='seconds') if user.updated_at else 'N/A'}",
]
),
title="User",
)
)
def print_json(console: Console, payload: Any) -> None:
console.print_json(data=to_plain_data(payload))
@@ -139,13 +175,22 @@ def render_output(console: Console, output_format: str, payload: Any, *, empty_m
if not payload and empty_message:
console.print(empty_message)
return
print_portfolio_table(console, payload)
if all(isinstance(item, PortfolioListItem) for item in payload):
print_portfolio_table(console, payload)
return
if all(isinstance(item, UserResponse) for item in payload):
print_user_table(console, payload)
return
return
if isinstance(payload, PortfolioDetailResponse):
print_portfolio_detail(console, payload)
return
if isinstance(payload, UserResponse):
print_user_detail(console, payload)
return
console.print(payload)
app/cli/main.py
+2
View File
@@ -11,6 +11,7 @@ from rich.console import Console
from app.cli.commands.health import register_health_commands
from app.cli.commands.portfolio import portfolio_app
from app.cli.commands.strategy import strategy_app
from app.cli.commands.user import user_app
from app.core.config import Settings, get_settings
from app.repositories.factory import get_portfolio_repository_from_settings
from app.repositories.portfolio_repository import PortfolioRepository
@@ -47,6 +48,7 @@ def create_app(
app.add_typer(portfolio_app, name="portfolio")
app.add_typer(strategy_app, name="strategy")
app.add_typer(user_app, name="user")
register_health_commands(app)
return app
app/domain/models.py
+9
View File
@@ -16,6 +16,15 @@ class StrategySet:
created_at: datetime | None = None
@dataclass
class User:
id: str
username: str
email: str | None = None
created_at: datetime | None = None
updated_at: datetime | None = None
@dataclass
class Portfolio:
portfolio_id: str
app/main.py
+2
View File
@@ -6,6 +6,7 @@ from fastapi.middleware.cors import CORSMiddleware
from app.api.health import router as health_router
from app.api.portfolios import router as portfolio_router
from app.api.strategy_sets import router as strategy_sets_router
from app.api.users import router as users_router
from app.core.config import get_settings
from app.core.errors import register_exception_handlers
@@ -30,6 +31,7 @@ def create_app() -> FastAPI:
app.include_router(health_router)
app.include_router(portfolio_router)
app.include_router(strategy_sets_router)
app.include_router(users_router)
register_exception_handlers(app)
return app
app/repositories/portfolio_repository.py
+11 -1
View File
@@ -4,12 +4,22 @@ from __future__ import annotations
from typing import Protocol
from app.domain.models import LedgerEntry, Portfolio, StrategySet
from app.domain.models import LedgerEntry, Portfolio, StrategySet, User
class PortfolioRepository(Protocol):
def ping(self) -> None: ...
def get_user(self, user_id: str) -> User: ...
def list_users(self) -> list[User]: ...
def create_user(self, username: str, *, email: str | None = None) -> User: ...
def update_user(self, user_id: str, *, username: str | None = None, email: str | None = None) -> User: ...
def delete_user(self, user_id: str) -> None: ...
def get(self, portfolio_id: str) -> Portfolio: ...
def get_or_create(
app/repositories/postgres.py
+132 -1
View File
@@ -12,7 +12,17 @@ from typing import Any
import psycopg
from psycopg import sql
from app.domain.models import LedgerEntry, Portfolio, StrategySet
from app.domain.models import LedgerEntry, Portfolio, StrategySet, User
_SELECT_USER = """
SELECT
id,
username,
email,
created_at,
updated_at
FROM users
"""
_SELECT_PORTFOLIO = """
SELECT
@@ -78,6 +88,17 @@ class PostgresPortfolioRepository:
def ensure_schema(self) -> None:
conn = self._connect()
with conn.cursor() as cur:
cur.execute(
"""
CREATE TABLE IF NOT EXISTS users (
id TEXT PRIMARY KEY,
username TEXT NOT NULL UNIQUE,
email TEXT UNIQUE,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
)
"""
)
cur.execute(
"""
CREATE TABLE IF NOT EXISTS strategy_sets (
@@ -148,6 +169,19 @@ class PostgresPortfolioRepository:
"""
)
@staticmethod
def _row_to_user(row: Any) -> User:
if row is None:
raise ValueError("사용자를 찾을 수 없습니다")
return User(
id=row[0],
username=row[1],
email=row[2],
created_at=row[3] if len(row) > 3 else None,
updated_at=row[4] if len(row) > 4 else None,
)
@staticmethod
def _row_to_portfolio(row: Any) -> Portfolio:
if row is None:
@@ -195,6 +229,103 @@ class PostgresPortfolioRepository:
note=row[12] or "",
)
def _ensure_user_uniqueness(
self,
cur: psycopg.Cursor,
*,
username: str | None = None,
email: str | None = None,
exclude_user_id: str | None = None,
) -> None:
if username is not None:
if exclude_user_id is None:
cur.execute("SELECT 1 FROM users WHERE username = %s", (username,))
else:
cur.execute("SELECT 1 FROM users WHERE username = %s AND id <> %s", (username, exclude_user_id))
if cur.fetchone() is not None:
raise ValueError(f"이미 존재하는 username입니다: {username}")
if email is not None:
if exclude_user_id is None:
cur.execute("SELECT 1 FROM users WHERE email = %s", (email,))
else:
cur.execute("SELECT 1 FROM users WHERE email = %s AND id <> %s", (email, exclude_user_id))
if cur.fetchone() is not None:
raise ValueError(f"이미 존재하는 email입니다: {email}")
def get_user(self, user_id: str) -> User:
self.ensure_schema()
with self._connect().cursor() as cur:
cur.execute(_SELECT_USER + "WHERE id = %s", (user_id,))
row = cur.fetchone()
return self._row_to_user(row)
def list_users(self) -> list[User]:
self.ensure_schema()
with self._connect().cursor() as cur:
cur.execute(_SELECT_USER + "ORDER BY created_at DESC, username ASC")
rows = cur.fetchall()
return [self._row_to_user(row) for row in rows]
def create_user(self, username: str, *, email: str | None = None) -> User:
self.ensure_schema()
with self._connect().cursor() as cur:
self._ensure_user_uniqueness(cur, username=username, email=email)
user_id = str(uuid.uuid4())
cur.execute(
"""
INSERT INTO users (id, username, email)
VALUES (%s, %s, %s)
RETURNING id, username, email, created_at, updated_at
""",
(user_id, username, email),
)
row = cur.fetchone()
return self._row_to_user(row)
def update_user(self, user_id: str, *, username: str | None = None, email: str | None = None) -> User:
self.ensure_schema()
assignments: list[str] = []
params: list[object] = []
with self._connect().cursor() as cur:
cur.execute(_SELECT_USER + "WHERE id = %s", (user_id,))
existing_row = cur.fetchone()
if existing_row is None:
raise ValueError("사용자를 찾을 수 없습니다")
self._ensure_user_uniqueness(cur, username=username, email=email, exclude_user_id=user_id)
if username is not None:
assignments.append("username = %s")
params.append(username)
if email is not None:
assignments.append("email = %s")
params.append(email)
if not assignments:
return self._row_to_user(existing_row)
assignments.append("updated_at = NOW()")
cur.execute(
f"""
UPDATE users
SET {', '.join(assignments)}
WHERE id = %s
RETURNING id, username, email, created_at, updated_at
""",
(*params, user_id),
)
row = cur.fetchone()
return self._row_to_user(row)
def delete_user(self, user_id: str) -> None:
self.ensure_schema()
with self._connect().cursor() as cur:
cur.execute("SELECT 1 FROM users WHERE id = %s", (user_id,))
if cur.fetchone() is None:
raise ValueError("사용자를 찾을 수 없습니다")
cur.execute("DELETE FROM users WHERE id = %s", (user_id,))
def get(self, portfolio_id: str) -> Portfolio:
self.ensure_schema()
with self._connect().cursor() as cur:
app/schemas/user.py
+59
View File
@@ -0,0 +1,59 @@
"""User request and response schemas."""
from __future__ import annotations
from datetime import datetime
from pydantic import BaseModel, Field, field_validator
class UserResponse(BaseModel):
id: str
username: str
email: str | None = None
created_at: datetime | None = None
updated_at: datetime | None = None
class CreateUserRequest(BaseModel):
username: str = Field(min_length=1)
email: str | None = None
@field_validator("username")
@classmethod
def normalize_username(cls, value: str) -> str:
normalized = value.strip()
if not normalized:
raise ValueError("username은 비어 있을 수 없습니다")
return normalized
@field_validator("email")
@classmethod
def normalize_email(cls, value: str | None) -> str | None:
if value is None:
return None
normalized = value.strip()
return normalized or None
class UpdateUserRequest(BaseModel):
username: str | None = Field(default=None, min_length=1)
email: str | None = None
@field_validator("username")
@classmethod
def normalize_username(cls, value: str | None) -> str | None:
if value is None:
return None
normalized = value.strip()
if not normalized:
raise ValueError("username은 비어 있을 수 없습니다")
return normalized
@field_validator("email")
@classmethod
def normalize_email(cls, value: str | None) -> str | None:
if value is None:
return None
normalized = value.strip()
return normalized or None
app/services/user_service.py
+43
View File
@@ -0,0 +1,43 @@
"""User service orchestration."""
from __future__ import annotations
from fastapi import Depends
from app.core.config import Settings, get_settings
from app.domain.models import User
from app.repositories.factory import get_portfolio_repository_from_settings
from app.repositories.portfolio_repository import PortfolioRepository
from app.schemas.user import CreateUserRequest, UpdateUserRequest
def get_user_repository(settings: Settings = Depends(get_settings)) -> PortfolioRepository:
return get_portfolio_repository_from_settings(settings)
class UserService:
def __init__(self, repository: PortfolioRepository) -> None:
self._repository = repository
def list(self) -> list[User]:
return self._repository.list_users()
def get(self, user_id: str) -> User:
return self._repository.get_user(user_id)
def create(self, payload: CreateUserRequest) -> User:
return self._repository.create_user(payload.username, email=payload.email)
def update(self, user_id: str, payload: UpdateUserRequest) -> User:
return self._repository.update_user(
user_id,
username=payload.username,
email=payload.email,
)
def delete(self, user_id: str) -> None:
self._repository.delete_user(user_id)
def get_user_service(repository: PortfolioRepository = Depends(get_user_repository)) -> UserService:
return UserService(repository)