845 lines
33 KiB
Python
845 lines
33 KiB
Python
from __future__ import annotations
|
|
|
|
from datetime import date as Date
|
|
|
|
from fastapi import APIRouter, Depends, HTTPException, Query
|
|
from fastapi.responses import JSONResponse
|
|
from sqlalchemy import and_, select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from ...core.database import get_db
|
|
from ...core.response import error_response, success_response
|
|
from ...dependencies import get_current_user
|
|
from ...models import Project, User, UserProject
|
|
from ...schemas.pmflow_os import (
|
|
PMFlowAIFeedbackCreateRequest,
|
|
PMFlowCapacityOverridePayload,
|
|
PMFlowChangeItemDeferRequest,
|
|
PMFlowChangeItemEditRequest,
|
|
PMFlowChangeSetCommitRequest,
|
|
PMFlowExecutionHandoffConsumeRequest,
|
|
PMFlowExecutionHandoffRequest,
|
|
PMFlowExecutionProgressEventRequest,
|
|
PMFlowExtractionCreateRequest,
|
|
PMFlowIterationRecommendationChangeSetDraftRequest,
|
|
PMFlowIterationRecommendationGroupChangeSetDraftRequest,
|
|
PMFlowReleaseFeedbackIngestRequest,
|
|
PMFlowReleaseValidationRunCreateRequest,
|
|
PMFlowReviewDecisionRequest,
|
|
PMFlowThreadMessageCreateRequest,
|
|
)
|
|
from ...services.auth import has_any_role
|
|
from ...services.adaptive_capacity_service import AdaptiveCapacityService
|
|
from ...services.pmflow_ai_feedback_service import PMFlowAIFeedbackService
|
|
from ...services.pmflow_change_review_service import PMFlowChangeReviewError, PMFlowChangeReviewService
|
|
from ...services.pmflow_os_projection_service import PMFlowOSProjectionService
|
|
from ...services.team_execution_capability_service import TeamExecutionCapabilityService
|
|
|
|
router = APIRouter(prefix="/pmflow-os", tags=["pmflow-os"])
|
|
|
|
|
|
def _review_error(exc: PMFlowChangeReviewError) -> JSONResponse:
|
|
return JSONResponse(status_code=exc.status_code, content=error_response(exc.status_code, f"{exc.code}: {exc.message}"))
|
|
|
|
|
|
async def _ensure_project_member_or_manager(
|
|
db: AsyncSession,
|
|
*,
|
|
tenant_id: int,
|
|
project_id: int,
|
|
current_user: User,
|
|
) -> None:
|
|
project_result = await db.execute(
|
|
select(Project.id).where(and_(Project.id == int(project_id), Project.tenant_id == int(tenant_id)))
|
|
)
|
|
if project_result.scalar_one_or_none() is None:
|
|
raise HTTPException(status_code=404, detail="project_not_found")
|
|
if has_any_role(str(getattr(current_user, "role", "") or ""), ["OWNER", "REVIEWER"]):
|
|
return
|
|
member_result = await db.execute(
|
|
select(UserProject.user_id).where(
|
|
and_(
|
|
UserProject.tenant_id == int(tenant_id),
|
|
UserProject.project_id == int(project_id),
|
|
UserProject.user_id == int(current_user.id),
|
|
)
|
|
)
|
|
)
|
|
if member_result.scalar_one_or_none() is None:
|
|
raise HTTPException(status_code=403, detail="forbidden")
|
|
|
|
|
|
def _ensure_capacity_override_manager(current_user: User) -> None:
|
|
if not has_any_role(str(getattr(current_user, "role", "") or ""), ["OWNER", "REVIEWER"]):
|
|
raise HTTPException(status_code=403, detail="forbidden")
|
|
|
|
|
|
def _parse_capacity_date(value: str | None) -> Date | None:
|
|
if not value:
|
|
return None
|
|
try:
|
|
return Date.fromisoformat(str(value)[:10])
|
|
except ValueError as exc:
|
|
raise HTTPException(status_code=422, detail="invalid_date") from exc
|
|
|
|
|
|
@router.get("/projects/{project_id}/truth-state")
|
|
async def get_pmflow_os_truth_state(
|
|
project_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.get_truth_state(
|
|
project_id=int(project_id),
|
|
current_user_id=int(current_user.id),
|
|
)
|
|
except ValueError as exc:
|
|
if str(exc) == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload.model_dump(mode="json"))
|
|
|
|
|
|
@router.get("/projects/{project_id}/project-memory/overview")
|
|
async def get_pmflow_os_project_memory_overview(
|
|
project_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=int(project_id), current_user=current_user)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.get_project_memory_overview(
|
|
project_id=int(project_id),
|
|
current_user_id=int(current_user.id),
|
|
)
|
|
except ValueError as exc:
|
|
if str(exc) == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload)
|
|
|
|
|
|
@router.get("/projects/{project_id}/project-memory/items")
|
|
async def get_pmflow_os_project_memory_items(
|
|
project_id: int,
|
|
category: str | None = Query(default=None),
|
|
stage: str | None = Query(default=None),
|
|
source_type: str | None = Query(default=None),
|
|
status: str | None = Query(default=None),
|
|
query: str | None = Query(default=None),
|
|
limit: int = Query(default=50, ge=1, le=200),
|
|
offset: int = Query(default=0, ge=0),
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=int(project_id), current_user=current_user)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.get_project_memory_items(
|
|
project_id=int(project_id),
|
|
category=category,
|
|
stage=stage,
|
|
source_type=source_type,
|
|
status=status,
|
|
query=query,
|
|
limit=int(limit),
|
|
offset=int(offset),
|
|
)
|
|
except ValueError as exc:
|
|
if str(exc) == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload)
|
|
|
|
|
|
@router.get("/projects/{project_id}/project-memory/items/{item_id}")
|
|
async def get_pmflow_os_project_memory_item(
|
|
project_id: int,
|
|
item_id: str,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=int(project_id), current_user=current_user)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.get_project_memory_item(project_id=int(project_id), item_id=item_id)
|
|
except ValueError as exc:
|
|
if str(exc) == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
if str(exc) == "project_memory_item_not_found":
|
|
raise HTTPException(status_code=404, detail="project_memory_item_not_found") from exc
|
|
raise
|
|
return success_response(payload)
|
|
|
|
|
|
@router.get("/projects/{project_id}/project-memory/assets")
|
|
async def get_pmflow_os_project_memory_assets(
|
|
project_id: int,
|
|
asset_type: str | None = Query(default=None),
|
|
source_type: str | None = Query(default=None),
|
|
status: str | None = Query(default=None),
|
|
query: str | None = Query(default=None),
|
|
limit: int = Query(default=50, ge=1, le=200),
|
|
offset: int = Query(default=0, ge=0),
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=int(project_id), current_user=current_user)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.get_project_memory_assets(
|
|
project_id=int(project_id),
|
|
asset_type=asset_type,
|
|
source_type=source_type,
|
|
status=status,
|
|
query=query,
|
|
limit=int(limit),
|
|
offset=int(offset),
|
|
)
|
|
except ValueError as exc:
|
|
if str(exc) == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload)
|
|
|
|
|
|
@router.get("/projects/{project_id}/project-memory/context-packs")
|
|
async def get_pmflow_os_project_memory_context_packs(
|
|
project_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=int(project_id), current_user=current_user)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.get_project_memory_context_packs(project_id=int(project_id))
|
|
except ValueError as exc:
|
|
if str(exc) == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload)
|
|
|
|
|
|
@router.get("/projects/{project_id}/project-memory/writebacks")
|
|
async def get_pmflow_os_project_memory_writebacks(
|
|
project_id: int,
|
|
limit: int = Query(default=50, ge=1, le=200),
|
|
offset: int = Query(default=0, ge=0),
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=int(project_id), current_user=current_user)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.get_project_memory_writebacks(project_id=int(project_id), limit=int(limit), offset=int(offset))
|
|
except ValueError as exc:
|
|
if str(exc) == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload)
|
|
|
|
|
|
@router.post("/projects/{project_id}/ai-feedback")
|
|
async def create_pmflow_os_ai_feedback(
|
|
project_id: int,
|
|
body: PMFlowAIFeedbackCreateRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
service = PMFlowAIFeedbackService(db, tenant_id=tenant_id)
|
|
payload = await service.create_or_update(project_id=int(project_id), body=body, user_id=int(current_user.id))
|
|
return success_response(payload.model_dump(mode="json"))
|
|
|
|
|
|
@router.post("/projects/{project_id}/threads/{thread_id}/messages")
|
|
async def create_pmflow_os_thread_message(
|
|
project_id: int,
|
|
thread_id: str,
|
|
body: PMFlowThreadMessageCreateRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=int(project_id), current_user=current_user)
|
|
service = PMFlowChangeReviewService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.create_thread_message(
|
|
project_id=int(project_id),
|
|
thread_id=thread_id,
|
|
body=body,
|
|
user_id=int(current_user.id),
|
|
)
|
|
except PMFlowChangeReviewError as exc:
|
|
return _review_error(exc)
|
|
return success_response(payload)
|
|
|
|
|
|
@router.post("/projects/{project_id}/extractions")
|
|
async def create_pmflow_os_extraction(
|
|
project_id: int,
|
|
body: PMFlowExtractionCreateRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=int(project_id), current_user=current_user)
|
|
service = PMFlowChangeReviewService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.create_extraction(project_id=int(project_id), body=body, user_id=int(current_user.id))
|
|
except PMFlowChangeReviewError as exc:
|
|
return _review_error(exc)
|
|
return success_response(payload)
|
|
|
|
|
|
@router.get("/projects/{project_id}/change-sets/{change_set_id}")
|
|
async def get_pmflow_os_change_set(
|
|
project_id: int,
|
|
change_set_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=int(project_id), current_user=current_user)
|
|
service = PMFlowChangeReviewService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.get_change_set_detail(project_id=int(project_id), change_set_id=int(change_set_id))
|
|
except PMFlowChangeReviewError as exc:
|
|
return _review_error(exc)
|
|
return success_response(payload)
|
|
|
|
|
|
@router.post("/change-items/{change_item_id}/accept")
|
|
async def accept_pmflow_os_change_item(
|
|
change_item_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
service = PMFlowChangeReviewService(db, tenant_id=tenant_id)
|
|
project_id = await service.get_item_project_id(change_item_id=int(change_item_id))
|
|
if project_id is None:
|
|
return JSONResponse(status_code=404, content=error_response(404, "change_item_not_found"))
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=project_id, current_user=current_user)
|
|
try:
|
|
payload = await service.accept_item(change_item_id=int(change_item_id), user_id=int(current_user.id))
|
|
except PMFlowChangeReviewError as exc:
|
|
return _review_error(exc)
|
|
return success_response(payload)
|
|
|
|
|
|
@router.post("/change-items/{change_item_id}/edit")
|
|
async def edit_pmflow_os_change_item(
|
|
change_item_id: int,
|
|
body: PMFlowChangeItemEditRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
service = PMFlowChangeReviewService(db, tenant_id=tenant_id)
|
|
project_id = await service.get_item_project_id(change_item_id=int(change_item_id))
|
|
if project_id is None:
|
|
return JSONResponse(status_code=404, content=error_response(404, "change_item_not_found"))
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=project_id, current_user=current_user)
|
|
try:
|
|
payload = await service.edit_item(change_item_id=int(change_item_id), body=body, user_id=int(current_user.id))
|
|
except PMFlowChangeReviewError as exc:
|
|
return _review_error(exc)
|
|
return success_response(payload)
|
|
|
|
|
|
@router.post("/change-items/{change_item_id}/defer")
|
|
async def defer_pmflow_os_change_item(
|
|
change_item_id: int,
|
|
body: PMFlowChangeItemDeferRequest | None = None,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
service = PMFlowChangeReviewService(db, tenant_id=tenant_id)
|
|
project_id = await service.get_item_project_id(change_item_id=int(change_item_id))
|
|
if project_id is None:
|
|
return JSONResponse(status_code=404, content=error_response(404, "change_item_not_found"))
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=project_id, current_user=current_user)
|
|
try:
|
|
payload = await service.defer_item(
|
|
change_item_id=int(change_item_id),
|
|
user_id=int(current_user.id),
|
|
reason=body.reason if body is not None else None,
|
|
)
|
|
except PMFlowChangeReviewError as exc:
|
|
return _review_error(exc)
|
|
return success_response(payload)
|
|
|
|
|
|
@router.post("/change-sets/{change_set_id}/commit")
|
|
async def commit_pmflow_os_change_set(
|
|
change_set_id: int,
|
|
body: PMFlowChangeSetCommitRequest | None = None,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
service = PMFlowChangeReviewService(db, tenant_id=tenant_id)
|
|
project_id = await service.get_change_set_project_id(change_set_id=int(change_set_id))
|
|
if project_id is None:
|
|
return JSONResponse(status_code=404, content=error_response(404, "changeset_not_found"))
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=project_id, current_user=current_user)
|
|
try:
|
|
payload = await service.commit_change_set(
|
|
change_set_id=int(change_set_id),
|
|
body=body or PMFlowChangeSetCommitRequest(),
|
|
user_id=int(current_user.id),
|
|
)
|
|
except PMFlowChangeReviewError as exc:
|
|
return _review_error(exc)
|
|
return success_response(payload)
|
|
|
|
|
|
@router.post("/change-sets/{change_set_id}/review-decisions")
|
|
async def create_pmflow_os_review_decision(
|
|
change_set_id: int,
|
|
body: PMFlowReviewDecisionRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
review_service = PMFlowChangeReviewService(db, tenant_id=tenant_id)
|
|
project_id = await review_service.get_change_set_project_id(change_set_id=int(change_set_id))
|
|
if project_id is None:
|
|
return JSONResponse(status_code=404, content=error_response(404, "changeset_not_found"))
|
|
await _ensure_project_member_or_manager(db, tenant_id=tenant_id, project_id=project_id, current_user=current_user)
|
|
try:
|
|
review_payload = await review_service.record_review_decision(
|
|
change_set_id=int(change_set_id),
|
|
body=body,
|
|
user_id=int(current_user.id),
|
|
)
|
|
truth_state = await PMFlowOSProjectionService(db, tenant_id=tenant_id).get_truth_state(
|
|
project_id=int(project_id),
|
|
current_user_id=int(current_user.id),
|
|
)
|
|
except PMFlowChangeReviewError as exc:
|
|
return _review_error(exc)
|
|
return success_response(
|
|
{
|
|
"changeSetDetail": review_payload["changeSetDetail"],
|
|
"truthState": truth_state.model_dump(mode="json"),
|
|
"warnings": review_payload.get("warnings", []),
|
|
}
|
|
)
|
|
|
|
|
|
@router.get("/projects/{project_id}/execution-summary")
|
|
async def get_pmflow_os_execution_summary(
|
|
project_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.get_execution_summary(
|
|
project_id=int(project_id),
|
|
current_user_id=int(current_user.id),
|
|
)
|
|
except ValueError as exc:
|
|
if str(exc) == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload.model_dump(mode="json"))
|
|
|
|
|
|
@router.get("/projects/{project_id}/execution-capabilities")
|
|
async def get_pmflow_os_execution_capabilities(
|
|
project_id: int,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
service = TeamExecutionCapabilityService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.get_snapshot(
|
|
project_id=int(project_id),
|
|
current_user_id=int(current_user.id),
|
|
)
|
|
except ValueError as exc:
|
|
if str(exc) == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload.model_dump(mode="json"))
|
|
|
|
|
|
@router.get("/projects/{project_id}/capacity-plan")
|
|
async def get_pmflow_os_capacity_plan(
|
|
project_id: int,
|
|
plan_date: str | None = Query(default=None, alias="date"),
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
service = AdaptiveCapacityService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.get_plan(
|
|
project_id=int(project_id),
|
|
current_user_id=int(current_user.id),
|
|
plan_date=_parse_capacity_date(plan_date),
|
|
)
|
|
except ValueError as exc:
|
|
if str(exc) == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload.model_dump(mode="json"))
|
|
|
|
|
|
@router.post("/projects/{project_id}/capacity-overrides/simulate")
|
|
async def simulate_pmflow_os_capacity_override(
|
|
project_id: int,
|
|
body: PMFlowCapacityOverridePayload,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
_ensure_capacity_override_manager(current_user)
|
|
service = AdaptiveCapacityService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.simulate_override(
|
|
project_id=int(project_id),
|
|
current_user_id=int(current_user.id),
|
|
payload=body,
|
|
)
|
|
except ValueError as exc:
|
|
if str(exc) == "capacity_member_not_found":
|
|
raise HTTPException(status_code=404, detail="capacity_member_not_found") from exc
|
|
raise
|
|
return success_response(payload.model_dump(mode="json"))
|
|
|
|
|
|
@router.post("/projects/{project_id}/capacity-overrides")
|
|
async def create_pmflow_os_capacity_override(
|
|
project_id: int,
|
|
body: PMFlowCapacityOverridePayload,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
_ensure_capacity_override_manager(current_user)
|
|
service = AdaptiveCapacityService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.apply_override(
|
|
project_id=int(project_id),
|
|
current_user_id=int(current_user.id),
|
|
payload=body,
|
|
)
|
|
except ValueError as exc:
|
|
if str(exc) == "capacity_member_not_found":
|
|
raise HTTPException(status_code=404, detail="capacity_member_not_found") from exc
|
|
raise
|
|
return success_response(payload.model_dump(mode="json"))
|
|
|
|
|
|
@router.get("/projects/{project_id}/capacity-overrides")
|
|
async def list_pmflow_os_capacity_overrides(
|
|
project_id: int,
|
|
plan_date: str | None = Query(default=None, alias="date"),
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
service = AdaptiveCapacityService(db, tenant_id=tenant_id)
|
|
payload = await service.list_overrides(project_id=int(project_id), plan_date=_parse_capacity_date(plan_date))
|
|
return success_response([item.model_dump(mode="json") for item in payload])
|
|
|
|
|
|
@router.post("/projects/{project_id}/execution-handoffs")
|
|
async def create_pmflow_os_execution_handoff(
|
|
project_id: int,
|
|
body: PMFlowExecutionHandoffRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.create_execution_handoff(
|
|
project_id=int(project_id),
|
|
body=body,
|
|
current_user_id=int(current_user.id),
|
|
)
|
|
except ValueError as exc:
|
|
code = str(exc)
|
|
if code == "task_not_found":
|
|
return JSONResponse(status_code=404, content=error_response(404, "task_not_found"))
|
|
if code == "repo_binding_not_found":
|
|
return JSONResponse(status_code=422, content=error_response(422, "repo_binding_not_found"))
|
|
if code == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload.model_dump(mode="json"))
|
|
|
|
|
|
@router.post("/projects/{project_id}/execution-progress-events")
|
|
async def create_pmflow_os_execution_progress_event(
|
|
project_id: int,
|
|
body: PMFlowExecutionProgressEventRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.record_execution_progress_event(
|
|
project_id=int(project_id),
|
|
body=body,
|
|
current_user_id=int(current_user.id),
|
|
)
|
|
except ValueError as exc:
|
|
code = str(exc)
|
|
if code == "task_not_found":
|
|
return JSONResponse(status_code=404, content=error_response(404, "task_not_found"))
|
|
if code == "repo_binding_not_found":
|
|
return JSONResponse(status_code=422, content=error_response(422, "repo_binding_not_found"))
|
|
if code == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload.model_dump(mode="json"))
|
|
|
|
|
|
@router.post("/projects/{project_id}/release-validation-runs")
|
|
async def create_pmflow_os_release_validation_run(
|
|
project_id: int,
|
|
body: PMFlowReleaseValidationRunCreateRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.create_release_validation_run(
|
|
project_id=int(project_id),
|
|
body=body,
|
|
current_user_id=int(current_user.id),
|
|
)
|
|
except ValueError as exc:
|
|
code = str(exc)
|
|
if code == "release_validation_evidence_empty":
|
|
return JSONResponse(status_code=409, content=error_response(409, "release_validation_evidence_empty"))
|
|
if code == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload)
|
|
|
|
|
|
@router.post("/projects/{project_id}/release-feedback-ingests")
|
|
async def create_pmflow_os_release_feedback_ingest(
|
|
project_id: int,
|
|
body: PMFlowReleaseFeedbackIngestRequest,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.create_release_feedback_ingest(
|
|
project_id=int(project_id),
|
|
body=body,
|
|
current_user_id=int(current_user.id),
|
|
)
|
|
except ValueError as exc:
|
|
code = str(exc)
|
|
if code in {"feedback_content_empty", "反馈内容不能为空"}:
|
|
return JSONResponse(status_code=400, content=error_response(400, "feedback_content_empty"))
|
|
if code == "charter_not_found":
|
|
return JSONResponse(status_code=404, content=error_response(404, "charter_not_found"))
|
|
if code == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload)
|
|
|
|
|
|
@router.post("/projects/{project_id}/iteration-recommendations/{recommendation_id}/change-set-drafts")
|
|
async def create_pmflow_os_iteration_recommendation_change_set_draft(
|
|
project_id: int,
|
|
recommendation_id: int,
|
|
body: PMFlowIterationRecommendationChangeSetDraftRequest | None = None,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.create_iteration_recommendation_change_set_draft(
|
|
project_id=int(project_id),
|
|
recommendation_id=int(recommendation_id),
|
|
body=body or PMFlowIterationRecommendationChangeSetDraftRequest(),
|
|
current_user_id=int(current_user.id),
|
|
)
|
|
except ValueError as exc:
|
|
code = str(exc)
|
|
if code == "iteration_recommendation_not_found":
|
|
return JSONResponse(status_code=404, content=error_response(404, "iteration_recommendation_not_found"))
|
|
if code == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload)
|
|
|
|
|
|
@router.post("/projects/{project_id}/iteration-recommendation-groups/{group_key}/change-set-drafts")
|
|
async def create_pmflow_os_iteration_recommendation_group_change_set_draft(
|
|
project_id: int,
|
|
group_key: str,
|
|
body: PMFlowIterationRecommendationGroupChangeSetDraftRequest | None = None,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.create_iteration_recommendation_group_change_set_draft(
|
|
project_id=int(project_id),
|
|
group_key=group_key,
|
|
body=body or PMFlowIterationRecommendationGroupChangeSetDraftRequest(),
|
|
current_user_id=int(current_user.id),
|
|
)
|
|
except ValueError as exc:
|
|
code = str(exc)
|
|
if code == "iteration_recommendation_group_not_found":
|
|
return JSONResponse(status_code=404, content=error_response(404, "iteration_recommendation_group_not_found"))
|
|
if code == "iteration_recommendation_not_found":
|
|
return JSONResponse(status_code=404, content=error_response(404, "iteration_recommendation_not_found"))
|
|
if code == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload)
|
|
|
|
|
|
@router.post("/projects/{project_id}/execution-handoffs/{prompt_package_id}/consume")
|
|
async def consume_pmflow_os_execution_handoff(
|
|
project_id: int,
|
|
prompt_package_id: int,
|
|
body: PMFlowExecutionHandoffConsumeRequest | None = None,
|
|
db: AsyncSession = Depends(get_db),
|
|
current_user: User = Depends(get_current_user),
|
|
):
|
|
tenant_id = int(current_user.tenant_id)
|
|
await _ensure_project_member_or_manager(
|
|
db,
|
|
tenant_id=tenant_id,
|
|
project_id=int(project_id),
|
|
current_user=current_user,
|
|
)
|
|
service = PMFlowOSProjectionService(db, tenant_id=tenant_id)
|
|
try:
|
|
payload = await service.consume_execution_handoff(
|
|
project_id=int(project_id),
|
|
prompt_package_id=int(prompt_package_id),
|
|
body=body or PMFlowExecutionHandoffConsumeRequest(),
|
|
current_user_id=int(current_user.id),
|
|
)
|
|
except ValueError as exc:
|
|
code = str(exc)
|
|
if code in {"prompt_package_not_found", "execution_handoff_not_found"}:
|
|
return JSONResponse(status_code=404, content=error_response(404, code))
|
|
if code == "task_not_found":
|
|
return JSONResponse(status_code=404, content=error_response(404, "task_not_found"))
|
|
if code == "repo_binding_not_found":
|
|
return JSONResponse(status_code=422, content=error_response(422, "repo_binding_not_found"))
|
|
if code == "project_not_found":
|
|
raise HTTPException(status_code=404, detail="project_not_found") from exc
|
|
raise
|
|
return success_response(payload.model_dump(mode="json"))
|