264 lines
8.9 KiB
Python
264 lines
8.9 KiB
Python
"""
|
|
C-5: 서비스 카탈로그 API 라우터
|
|
|
|
엔드포인트:
|
|
GET /api/catalog/ — 서비스 카탈로그 목록
|
|
POST /api/catalog/ — 서비스 항목 등록 (관리자)
|
|
GET /api/catalog/{service_id} — 서비스 항목 상세
|
|
PATCH /api/catalog/{service_id} — 서비스 항목 수정
|
|
DELETE /api/catalog/{service_id} — 서비스 항목 폐기
|
|
POST /api/catalog/{service_id}/request — 서비스 요청 (SR 자동 생성)
|
|
GET /api/catalog/categories — 카테고리 목록
|
|
GET /api/catalog/stats — 카탈로그 통계
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from datetime import datetime
|
|
from typing import List, Optional
|
|
|
|
from fastapi import APIRouter, Body, Depends, HTTPException, Query
|
|
from pydantic import BaseModel
|
|
from sqlalchemy import select, desc, func, and_
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from core.auth import get_current_user
|
|
from database import get_db
|
|
from models import (
|
|
User, UserRole,
|
|
ServiceItem, ServiceItemOut, ServiceItemCreate, ServiceItemUpdate,
|
|
ServiceStatus,
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
router = APIRouter(prefix="/api/catalog", tags=["catalog"])
|
|
|
|
|
|
async def _next_service_id(db: AsyncSession) -> str:
|
|
"""SVC-NNNN 형식 서비스 ID 생성."""
|
|
last = (await db.execute(
|
|
select(ServiceItem.service_id)
|
|
.where(ServiceItem.service_id.like("SVC-%"))
|
|
.order_by(desc(ServiceItem.service_id)).limit(1)
|
|
)).scalar()
|
|
seq = 1
|
|
if last:
|
|
try:
|
|
seq = int(last.split("-")[-1]) + 1
|
|
except ValueError:
|
|
seq = 1
|
|
return f"SVC-{seq:04d}"
|
|
|
|
|
|
async def _get_service(db: AsyncSession, service_id: str) -> ServiceItem:
|
|
svc = (await db.execute(
|
|
select(ServiceItem).where(ServiceItem.service_id == service_id)
|
|
)).scalars().first()
|
|
if not svc:
|
|
raise HTTPException(404, f"서비스 {service_id}를 찾을 수 없습니다.")
|
|
return svc
|
|
|
|
|
|
@router.get("/categories")
|
|
async def list_categories(
|
|
db: AsyncSession = Depends(get_db),
|
|
_u: User = Depends(get_current_user),
|
|
):
|
|
"""카테고리 목록 조회."""
|
|
cats = (await db.execute(
|
|
select(ServiceItem.category, func.count())
|
|
.where(ServiceItem.status == ServiceStatus.ACTIVE.value)
|
|
.group_by(ServiceItem.category)
|
|
.order_by(ServiceItem.category)
|
|
)).all()
|
|
return [{"category": c, "count": cnt} for c, cnt in cats if c]
|
|
|
|
|
|
@router.get("/stats")
|
|
async def catalog_stats(
|
|
db: AsyncSession = Depends(get_db),
|
|
_u: User = Depends(get_current_user),
|
|
):
|
|
"""서비스 카탈로그 통계."""
|
|
total = (await db.execute(select(func.count()).select_from(ServiceItem))).scalar() or 0
|
|
active = (await db.execute(
|
|
select(func.count()).select_from(ServiceItem).where(ServiceItem.status == "ACTIVE")
|
|
)).scalar() or 0
|
|
total_requests = (await db.execute(
|
|
select(func.sum(ServiceItem.request_count)).select_from(ServiceItem)
|
|
)).scalar() or 0
|
|
avg_satisfaction = (await db.execute(
|
|
select(func.avg(ServiceItem.satisfaction)).select_from(ServiceItem)
|
|
.where(ServiceItem.satisfaction != None)
|
|
)).scalar()
|
|
|
|
return {
|
|
"total_services": total,
|
|
"active_services": active,
|
|
"total_requests": total_requests,
|
|
"avg_satisfaction": round(float(avg_satisfaction), 2) if avg_satisfaction else None,
|
|
}
|
|
|
|
|
|
@router.get("/", response_model=List[ServiceItemOut])
|
|
async def list_catalog(
|
|
category: Optional[str] = Query(None),
|
|
status: Optional[str] = Query(None, enum=["ACTIVE", "DRAFT", "DEPRECATED", "RETIRED"]),
|
|
keyword: Optional[str] = Query(None),
|
|
limit: int = Query(50, ge=1, le=200),
|
|
offset: int = Query(0, ge=0),
|
|
db: AsyncSession = Depends(get_db),
|
|
_u: User = Depends(get_current_user),
|
|
):
|
|
"""서비스 카탈로그 목록."""
|
|
conditions = []
|
|
if category: conditions.append(ServiceItem.category == category)
|
|
if status: conditions.append(ServiceItem.status == status.upper())
|
|
else: conditions.append(ServiceItem.status == ServiceStatus.ACTIVE.value)
|
|
if keyword: conditions.append(ServiceItem.name.ilike(f"%{keyword}%"))
|
|
|
|
q = (
|
|
select(ServiceItem)
|
|
.where(and_(*conditions))
|
|
.order_by(ServiceItem.category, ServiceItem.name)
|
|
.limit(limit).offset(offset)
|
|
)
|
|
return (await db.execute(q)).scalars().all()
|
|
|
|
|
|
@router.post("/", response_model=ServiceItemOut, status_code=201)
|
|
async def create_service(
|
|
body: ServiceItemCreate,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
"""서비스 카탈로그 항목 등록."""
|
|
if current_user.role not in (UserRole.ADMIN, UserRole.PM):
|
|
raise HTTPException(403, "서비스 등록은 PM/ADMIN 권한이 필요합니다.")
|
|
service_id = await _next_service_id(db)
|
|
svc = ServiceItem(
|
|
service_id = service_id,
|
|
name = body.name,
|
|
category = body.category,
|
|
description = body.description,
|
|
status = body.status.upper(),
|
|
sla_response_h = body.sla_response_h,
|
|
sla_resolve_h = body.sla_resolve_h,
|
|
sla_availability = body.sla_availability,
|
|
approval_required = body.approval_required,
|
|
auto_assignee = body.auto_assignee,
|
|
estimated_hours = body.estimated_hours,
|
|
charge_per_request = body.charge_per_request,
|
|
owner = body.owner,
|
|
tags = body.tags,
|
|
created_by = current_user.username,
|
|
)
|
|
db.add(svc)
|
|
await db.commit()
|
|
await db.refresh(svc)
|
|
return svc
|
|
|
|
|
|
@router.get("/{service_id}", response_model=ServiceItemOut)
|
|
async def get_service(
|
|
service_id: str,
|
|
db: AsyncSession = Depends(get_db),
|
|
_u: User = Depends(get_current_user),
|
|
):
|
|
return await _get_service(db, service_id)
|
|
|
|
|
|
@router.patch("/{service_id}", response_model=ServiceItemOut)
|
|
async def update_service(
|
|
service_id: str,
|
|
body: ServiceItemUpdate,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
"""서비스 항목 수정."""
|
|
if current_user.role not in (UserRole.ADMIN, UserRole.PM):
|
|
raise HTTPException(403, "PM/ADMIN 권한이 필요합니다.")
|
|
svc = await _get_service(db, service_id)
|
|
for k, v in body.model_dump(exclude_unset=True, exclude_none=True).items():
|
|
setattr(svc, k, v)
|
|
await db.commit()
|
|
await db.refresh(svc)
|
|
return svc
|
|
|
|
|
|
@router.delete("/{service_id}", status_code=204)
|
|
async def retire_service(
|
|
service_id: str,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
"""서비스 항목 폐기 (RETIRED 상태)."""
|
|
if current_user.role not in (UserRole.ADMIN, UserRole.PM):
|
|
raise HTTPException(403, "PM/ADMIN 권한이 필요합니다.")
|
|
svc = await _get_service(db, service_id)
|
|
svc.status = ServiceStatus.RETIRED.value
|
|
await db.commit()
|
|
|
|
|
|
@router.post("/{service_id}/request")
|
|
async def request_service(
|
|
service_id: str,
|
|
description: Optional[str] = Body(None, embed=True),
|
|
priority: str = Body("MEDIUM", embed=True),
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
"""
|
|
서비스 카탈로그를 통한 SR 요청.
|
|
- 서비스 SLA를 SR에 자동 적용
|
|
- 승인 필요 서비스는 PENDING_APPROVAL 상태로 생성
|
|
"""
|
|
from models import SRRequest
|
|
|
|
svc = await _get_service(db, service_id)
|
|
if svc.status != ServiceStatus.ACTIVE.value:
|
|
raise HTTPException(400, f"활성 서비스가 아닙니다: {svc.status}")
|
|
|
|
# SR 생성
|
|
today = datetime.utcnow().strftime("%Y%m%d")
|
|
prefix = f"SR-{today}-"
|
|
last_sr = (await db.execute(
|
|
select(SRRequest.sr_id).where(SRRequest.sr_id.like(f"{prefix}%"))
|
|
.order_by(desc(SRRequest.sr_id)).limit(1)
|
|
)).scalar()
|
|
seq = 1
|
|
if last_sr:
|
|
try:
|
|
seq = int(last_sr.split("-")[-1]) + 1
|
|
except ValueError:
|
|
seq = 1
|
|
sr_id = f"{prefix}{seq:04d}"
|
|
|
|
status = "PENDING_APPROVAL" if svc.approval_required else "OPEN"
|
|
sr = SRRequest(
|
|
sr_id = sr_id,
|
|
title = f"[카탈로그] {svc.name}",
|
|
description = description or f"서비스 카탈로그 요청: {svc.name}",
|
|
status = status,
|
|
priority = priority.upper(),
|
|
sr_type = "OTHER",
|
|
created_at = datetime.utcnow(),
|
|
)
|
|
db.add(sr)
|
|
|
|
# 요청 카운트 증가
|
|
svc.request_count = (svc.request_count or 0) + 1
|
|
|
|
await db.commit()
|
|
|
|
return {
|
|
"sr_id": sr_id,
|
|
"service_id": service_id,
|
|
"service_name": svc.name,
|
|
"status": status,
|
|
"approval_required": svc.approval_required,
|
|
"sla_response_h": svc.sla_response_h,
|
|
"sla_resolve_h": svc.sla_resolve_h,
|
|
"estimated_hours": svc.estimated_hours,
|
|
}
|