member-platform/backend/app/api/internal_catalog.py

from fastapi import APIRouter, Depends, Query
from sqlalchemy.orm import Session

from app.db.session import get_db
from app.repositories.companies_repo import CompaniesRepository
from app.repositories.roles_repo import RolesRepository
from app.repositories.sites_repo import SitesRepository
from app.repositories.systems_repo import SystemsRepository
from app.repositories.users_repo import UsersRepository
from app.schemas.internal import (
    InternalCompanyListResponse,
    InternalMemberListResponse,
    InternalRoleItem,
    InternalRoleListResponse,
    InternalSiteListResponse,
    InternalSystemListResponse,
)
from app.security.api_client_auth import require_api_client

router = APIRouter(prefix="/internal", tags=["internal"], dependencies=[Depends(require_api_client)])


@router.get("/systems", response_model=InternalSystemListResponse)
def internal_list_systems(
    db: Session = Depends(get_db),
    limit: int = Query(default=200, ge=1, le=1000),
    offset: int = Query(default=0, ge=0),
) -> InternalSystemListResponse:
    repo = SystemsRepository(db)
    items, total = repo.list(limit=limit, offset=offset)
    return {
        "items": [
            {
                "id": i.id,
                "system_key": i.system_key,
                "name": i.name,
                "provider_client_id": i.provider_client_id,
                "status": i.status,
            }
            for i in items
        ],
        "total": total,
        "limit": limit,
        "offset": offset,
    }


@router.get("/roles", response_model=InternalRoleListResponse)
def internal_list_roles(
    db: Session = Depends(get_db),
    system_key: str | None = Query(default=None),
    limit: int = Query(default=500, ge=1, le=2000),
    offset: int = Query(default=0, ge=0),
) -> InternalRoleListResponse:
    systems_repo = SystemsRepository(db)
    roles_repo = RolesRepository(db)

    system_id = None
    systems, _ = systems_repo.list(limit=5000, offset=0)
    system_map = {s.id: s for s in systems}
    if system_key:
        system = systems_repo.get_by_key(system_key)
        if not system:
            return InternalRoleListResponse(items=[], total=0, limit=limit, offset=offset)
        system_id = system.id

    items, total = roles_repo.list(system_id=system_id, limit=limit, offset=offset)
    rows = [
        InternalRoleItem(
            id=i.id,
            role_key=i.role_key,
            system_key=system_map[i.system_id].system_key,
            system_name=system_map[i.system_id].name,
            name=i.name,
            provider_role_name=i.provider_role_name,
            description=i.description,
            status=i.status,
        )
        for i in items
        if i.system_id in system_map
    ]
    return InternalRoleListResponse(items=rows, total=total, limit=limit, offset=offset)


@router.get("/companies", response_model=InternalCompanyListResponse)
def internal_list_companies(
    db: Session = Depends(get_db),
    keyword: str | None = Query(default=None),
    limit: int = Query(default=500, ge=1, le=2000),
    offset: int = Query(default=0, ge=0),
) -> InternalCompanyListResponse:
    repo = CompaniesRepository(db)
    items, total = repo.list(keyword=keyword, limit=limit, offset=offset)
    return {
        "items": [
            {
                "id": i.id,
                "company_key": i.company_key,
                "display_name": i.display_name,
                "legal_name": i.legal_name,
                "status": i.status,
            }
            for i in items
        ],
        "total": total,
        "limit": limit,
        "offset": offset,
    }


@router.get("/sites", response_model=InternalSiteListResponse)
def internal_list_sites(
    db: Session = Depends(get_db),
    company_key: str | None = Query(default=None),
    limit: int = Query(default=500, ge=1, le=2000),
    offset: int = Query(default=0, ge=0),
) -> InternalSiteListResponse:
    companies_repo = CompaniesRepository(db)
    sites_repo = SitesRepository(db)
    company_id = None
    if company_key:
        company = companies_repo.get_by_key(company_key)
        if company:
            company_id = company.id
    companies, _ = companies_repo.list(limit=5000, offset=0)
    mapping = {c.id: c for c in companies}
    items, total = sites_repo.list(company_id=company_id, limit=limit, offset=offset)
    return {
        "items": [
            {
                "id": i.id,
                "site_key": i.site_key,
                "company_key": mapping[i.company_id].company_key,
                "company_display_name": mapping[i.company_id].display_name,
                "display_name": i.display_name,
                "domain": i.domain,
                "status": i.status,
            }
            for i in items
            if i.company_id in mapping
        ],
        "total": total,
        "limit": limit,
        "offset": offset,
    }


@router.get("/members", response_model=InternalMemberListResponse)
def internal_list_members(
    db: Session = Depends(get_db),
    keyword: str | None = Query(default=None),
    limit: int = Query(default=500, ge=1, le=2000),
    offset: int = Query(default=0, ge=0),
) -> InternalMemberListResponse:
    repo = UsersRepository(db)
    items, total = repo.list(keyword=keyword, limit=limit, offset=offset)
    return {
        "items": [
            {
                "id": i.id,
                "user_sub": i.user_sub,
                "username": i.username,
                "email": i.email,
                "display_name": i.display_name,
                "is_active": i.is_active,
                "status": i.status,
            }
            for i in items
        ],
        "total": total,
        "limit": limit,
        "offset": offset,
    }