184 lines
6.8 KiB
Python
184 lines
6.8 KiB
Python
"""项目管理路由"""
|
|
from fastapi import APIRouter, Depends, HTTPException, Query
|
|
from sqlalchemy.orm import Session
|
|
from sqlalchemy import func as sa_func
|
|
from typing import List, Optional
|
|
from database import get_db
|
|
from models import (
|
|
User, Project, Submission, ProjectType,
|
|
ProjectStatus, PhaseGroup, WorkType
|
|
)
|
|
from schemas import ProjectCreate, ProjectUpdate, ProjectOut
|
|
from auth import get_current_user, require_permission
|
|
|
|
router = APIRouter(prefix="/api/projects", tags=["项目管理"])
|
|
|
|
|
|
def enrich_project(p: Project, db: Session) -> ProjectOut:
|
|
"""将项目对象转为带计算字段的输出"""
|
|
# 累计提交秒数（仅有秒数的提交）
|
|
total_secs = db.query(sa_func.sum(Submission.total_seconds)).filter(
|
|
Submission.project_id == p.id,
|
|
Submission.total_seconds > 0
|
|
).scalar() or 0
|
|
|
|
target = p.target_total_seconds
|
|
progress = round(total_secs / target * 100, 1) if target > 0 else 0
|
|
|
|
# 损耗 = 测试损耗 + 超产损耗
|
|
test_secs = db.query(sa_func.sum(Submission.total_seconds)).filter(
|
|
Submission.project_id == p.id,
|
|
Submission.work_type == WorkType.TEST
|
|
).scalar() or 0
|
|
overproduction = max(0, total_secs - target)
|
|
waste = test_secs + overproduction
|
|
waste_rate = round(waste / target * 100, 1) if target > 0 else 0
|
|
|
|
leader_name = p.leader.name if p.leader else None
|
|
|
|
return ProjectOut(
|
|
id=p.id, name=p.name,
|
|
project_type=p.project_type.value if hasattr(p.project_type, 'value') else p.project_type,
|
|
status=p.status.value if hasattr(p.status, 'value') else p.status,
|
|
leader_id=p.leader_id, leader_name=leader_name,
|
|
current_phase=p.current_phase.value if hasattr(p.current_phase, 'value') else p.current_phase,
|
|
episode_duration_minutes=p.episode_duration_minutes,
|
|
episode_count=p.episode_count,
|
|
target_total_seconds=target,
|
|
estimated_completion_date=p.estimated_completion_date,
|
|
actual_completion_date=p.actual_completion_date,
|
|
contract_amount=p.contract_amount,
|
|
created_at=p.created_at,
|
|
total_submitted_seconds=round(total_secs, 1),
|
|
progress_percent=progress,
|
|
waste_seconds=round(waste, 1),
|
|
waste_rate=waste_rate,
|
|
)
|
|
|
|
|
|
@router.get("/", response_model=List[ProjectOut])
|
|
def list_projects(
|
|
status: Optional[str] = Query(None),
|
|
project_type: Optional[str] = Query(None),
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_user)
|
|
):
|
|
q = db.query(Project)
|
|
if status:
|
|
q = q.filter(Project.status == ProjectStatus(status))
|
|
if project_type:
|
|
q = q.filter(Project.project_type == ProjectType(project_type))
|
|
projects = q.order_by(Project.created_at.desc()).all()
|
|
return [enrich_project(p, db) for p in projects]
|
|
|
|
|
|
@router.post("/", response_model=ProjectOut)
|
|
def create_project(
|
|
req: ProjectCreate,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(require_permission("project:create"))
|
|
):
|
|
project = Project(
|
|
name=req.name,
|
|
project_type=ProjectType(req.project_type),
|
|
leader_id=req.leader_id,
|
|
current_phase=PhaseGroup(req.current_phase),
|
|
episode_duration_minutes=req.episode_duration_minutes,
|
|
episode_count=req.episode_count,
|
|
estimated_completion_date=req.estimated_completion_date,
|
|
contract_amount=req.contract_amount,
|
|
)
|
|
db.add(project)
|
|
db.commit()
|
|
db.refresh(project)
|
|
return enrich_project(project, db)
|
|
|
|
|
|
@router.get("/{project_id}", response_model=ProjectOut)
|
|
def get_project(
|
|
project_id: int,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_user)
|
|
):
|
|
p = db.query(Project).filter(Project.id == project_id).first()
|
|
if not p:
|
|
raise HTTPException(status_code=404, detail="项目不存在")
|
|
return enrich_project(p, db)
|
|
|
|
|
|
@router.put("/{project_id}", response_model=ProjectOut)
|
|
def update_project(
|
|
project_id: int,
|
|
req: ProjectUpdate,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(require_permission("project:edit"))
|
|
):
|
|
p = db.query(Project).filter(Project.id == project_id).first()
|
|
if not p:
|
|
raise HTTPException(status_code=404, detail="项目不存在")
|
|
if req.name is not None:
|
|
p.name = req.name
|
|
if req.project_type is not None:
|
|
p.project_type = ProjectType(req.project_type)
|
|
if req.status is not None:
|
|
p.status = ProjectStatus(req.status)
|
|
if req.leader_id is not None:
|
|
p.leader_id = req.leader_id
|
|
if req.current_phase is not None:
|
|
p.current_phase = PhaseGroup(req.current_phase)
|
|
if req.episode_duration_minutes is not None:
|
|
p.episode_duration_minutes = req.episode_duration_minutes
|
|
if req.episode_count is not None:
|
|
p.episode_count = req.episode_count
|
|
if req.estimated_completion_date is not None:
|
|
p.estimated_completion_date = req.estimated_completion_date
|
|
if req.actual_completion_date is not None:
|
|
p.actual_completion_date = req.actual_completion_date
|
|
if req.contract_amount is not None:
|
|
p.contract_amount = req.contract_amount
|
|
db.commit()
|
|
db.refresh(p)
|
|
return enrich_project(p, db)
|
|
|
|
|
|
@router.delete("/{project_id}")
|
|
def delete_project(
|
|
project_id: int,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(require_permission("project:delete"))
|
|
):
|
|
"""删除项目及其关联数据"""
|
|
from models import OutsourceCost, AIToolCostAllocation, CostOverride, SubmissionHistory
|
|
p = db.query(Project).filter(Project.id == project_id).first()
|
|
if not p:
|
|
raise HTTPException(status_code=404, detail="项目不存在")
|
|
|
|
# 删除关联数据
|
|
subs = db.query(Submission).filter(Submission.project_id == project_id).all()
|
|
for s in subs:
|
|
db.query(SubmissionHistory).filter(SubmissionHistory.submission_id == s.id).delete()
|
|
db.query(Submission).filter(Submission.project_id == project_id).delete()
|
|
db.query(OutsourceCost).filter(OutsourceCost.project_id == project_id).delete()
|
|
db.query(AIToolCostAllocation).filter(AIToolCostAllocation.project_id == project_id).delete()
|
|
db.query(CostOverride).filter(CostOverride.project_id == project_id).delete()
|
|
db.delete(p)
|
|
db.commit()
|
|
return {"message": "项目已删除"}
|
|
|
|
|
|
@router.post("/{project_id}/complete")
|
|
def complete_project(
|
|
project_id: int,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(require_permission("project:complete"))
|
|
):
|
|
"""Owner 手动确认项目完成"""
|
|
p = db.query(Project).filter(Project.id == project_id).first()
|
|
if not p:
|
|
raise HTTPException(status_code=404, detail="项目不存在")
|
|
from datetime import date
|
|
p.status = ProjectStatus.COMPLETED
|
|
p.actual_completion_date = date.today()
|
|
db.commit()
|
|
return {"message": "项目已标记为完成", "project_id": project_id}
|