清除“Task”模块

2025-12-19 11:02:21 +08:00
parent 81412fe906
commit b475d4f763
30 changed files with 58 additions and 1090 deletions
@@ -1,6 +1,6 @@
 from fastapi import APIRouter, Depends

-from app.constants import ae, finance, imp, issue, subject, task
+from app.constants import ae, finance, imp, issue, subject
 from app.core.deps import get_current_user

 router = APIRouter(tags=["FAQ"], dependencies=[Depends(get_current_user)])
@@ -13,7 +13,6 @@ router = APIRouter(tags=["FAQ"], dependencies=[Depends(get_current_user)])
 )
 async def get_constants():
    return {
-        "task": {"status": task.TASK_STATUS, "priority": task.TASK_PRIORITY},
        "subject": {"status": subject.SUBJECT_STATUS, "visit_status": subject.VISIT_STATUS},
        "ae": {"seriousness": ae.AE_SERIOUSNESS, "severity": ae.AE_SEVERITY, "status": ae.AE_STATUS},
        "issue": {"category": issue.ISSUE_CATEGORY, "level": issue.ISSUE_LEVEL, "status": issue.ISSUE_STATUS},
@@ -1,13 +1,10 @@
 import uuid
-from datetime import date
-
 from fastapi import APIRouter, Depends
 from sqlalchemy import func, select
 from sqlalchemy.ext.asyncio import AsyncSession

 from app.core.deps import get_db_session, require_study_member
 from app.models.milestone import Milestone
-from app.models.task import Task
 from app.schemas.progress import StudyProgressRead

 router = APIRouter()
@@ -18,34 +15,18 @@ async def get_progress(
    study_id: uuid.UUID,
    db: AsyncSession = Depends(get_db_session),
 ) -> StudyProgressRead:
-    # Milestones
    milestone_total_stmt = select(func.count()).select_from(Milestone).where(Milestone.study_id == study_id)
    milestone_done_stmt = select(func.count()).select_from(Milestone).where(
        Milestone.study_id == study_id, Milestone.status == "DONE"
    )
-    task_total_stmt = select(func.count()).select_from(Task).where(Task.study_id == study_id)
-    task_done_stmt = select(func.count()).select_from(Task).where(Task.study_id == study_id, Task.status == "DONE")
-    task_overdue_stmt = select(func.count()).select_from(Task).where(
-        Task.study_id == study_id,
-        Task.due_date < date.today(),
-        Task.status != "DONE",
-    )

    milestone_total = (await db.execute(milestone_total_stmt)).scalar_one()
    milestone_done = (await db.execute(milestone_done_stmt)).scalar_one()
-    task_total = (await db.execute(task_total_stmt)).scalar_one()
-    task_done = (await db.execute(task_done_stmt)).scalar_one()
-    task_overdue = (await db.execute(task_overdue_stmt)).scalar_one()

-    total_items = milestone_total + task_total
-    done_items = milestone_done + task_done
-    completion_rate = float(done_items / total_items) if total_items else 0.0
+    completion_rate = float(milestone_done / milestone_total) if milestone_total else 0.0

    return StudyProgressRead(
        milestones_total=milestone_total,
        milestones_done=milestone_done,
-        tasks_total=task_total,
-        tasks_done=task_done,
-        tasks_overdue=task_overdue,
        completion_rate=completion_rate,
    )
@@ -1,6 +1,6 @@
 from fastapi import APIRouter

-from app.api.v1 import auth, users, studies, sites, members, comments, attachments, audit_logs, milestones, tasks, dashboard, subjects, visits, aes, issues, data_queries, verifications, imp_products, imp_batches, imp_inventory, imp_transactions, finance, finance_dashboard, faq_categories, faqs, constants
+from app.api.v1 import auth, users, studies, sites, members, comments, attachments, audit_logs, milestones, dashboard, subjects, visits, aes, issues, data_queries, verifications, imp_products, imp_batches, imp_inventory, imp_transactions, finance, finance_dashboard, faq_categories, faqs, constants

 api_router = APIRouter()
 api_router.include_router(auth.router, prefix="/auth", tags=["auth"])
@@ -13,7 +13,6 @@ api_router.include_router(attachments.router, prefix="/studies/{study_id}/{entit
 api_router.include_router(attachments.global_router, prefix="/attachments", tags=["attachments"])
 api_router.include_router(audit_logs.router, prefix="/studies/{study_id}/audit-logs", tags=["audit-logs"])
 api_router.include_router(milestones.router, prefix="/studies/{study_id}/milestones", tags=["milestones"])
-api_router.include_router(tasks.router, prefix="/studies/{study_id}/tasks", tags=["tasks"])
 api_router.include_router(dashboard.router, prefix="/studies/{study_id}/dashboard", tags=["dashboard"])
 api_router.include_router(subjects.router, prefix="/studies/{study_id}/subjects", tags=["subjects"])
 api_router.include_router(visits.router, prefix="/studies/{study_id}/subjects/{subject_id}/visits", tags=["visits"])
@@ -1,147 +0,0 @@
-import uuid
-
-from fastapi import APIRouter, Depends, HTTPException, status
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.core.deps import get_current_user, get_db_session, require_study_member, require_study_roles
-from app.crud import audit as audit_crud
-from app.crud import milestone as milestone_crud
-from app.crud import study as study_crud
-from app.crud import task as task_crud
-from app.crud import user as user_crud
-from app.schemas.task import TaskCreate, TaskRead, TaskUpdate
-from app.schemas.user import UserDisplay
-
-router = APIRouter()
-
-ALLOW_ASSIGNEE_UPDATE_STATUS = False
-
-
-async def _ensure_study_exists(db: AsyncSession, study_id: uuid.UUID):
-    study = await study_crud.get(db, study_id)
-    if not study:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Study not found")
-    return study
-
-
-async def _validate_milestone(db: AsyncSession, study_id: uuid.UUID, milestone_id: uuid.UUID | None):
-    if milestone_id is None:
-        return
-    milestone = await milestone_crud.get(db, milestone_id)
-    if not milestone:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Milestone not found")
-    if milestone.study_id != study_id:
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail="Milestone does not belong to study")
-
-
-@router.post(
-    "/",
-    response_model=TaskRead,
-    status_code=status.HTTP_201_CREATED,
-    dependencies=[Depends(require_study_roles(["PM"]))],
-)
-async def create_task(
-    study_id: uuid.UUID,
-    task_in: TaskCreate,
-    db: AsyncSession = Depends(get_db_session),
-    current_user=Depends(get_current_user),
-) -> TaskRead:
-    await _ensure_study_exists(db, study_id)
-    await _validate_milestone(db, study_id, task_in.milestone_id)
-    task = await task_crud.create(db, study_id, task_in, created_by=current_user.id)
-    assignee = None
-    if task.assignee_id:
-        assignee = await user_crud.get_by_id(db, task.assignee_id)
-    await audit_crud.log_action(
-        db,
-        study_id=study_id,
-        entity_type="task",
-        entity_id=task.id,
-        action="CREATE_TASK",
-        detail=f"Task {task.id} created",
-        operator_id=current_user.id,
-        operator_role=current_user.role,
-    )
-    return _to_task_read(task, assignee)
-
-
-@router.get(
-    "/",
-    response_model=list[TaskRead],
-    dependencies=[Depends(require_study_member())],
-)
-async def list_tasks(
-    study_id: uuid.UUID,
-    milestone_id: uuid.UUID | None = None,
-    assignee_id: uuid.UUID | None = None,
-    status: str | None = None,
-    db: AsyncSession = Depends(get_db_session),
-) -> list[TaskRead]:
-    await _ensure_study_exists(db, study_id)
-    tasks = await task_crud.list_tasks(db, study_id, milestone_id=milestone_id, assignee_id=assignee_id, status=status)
-    assignee_ids = {t.assignee_id for t in tasks if t.assignee_id}
-    users_map = await user_crud.get_users_by_ids(db, assignee_ids)
-    result: list[TaskRead] = []
-    for t in tasks:
-        user = users_map.get(t.assignee_id)
-        result.append(_to_task_read(t, user))
-    return result
-
-
-@router.patch(
-    "/{task_id}",
-    response_model=TaskRead,
-    dependencies=[Depends(require_study_roles(["PM"]))],
-)
-async def update_task(
-    study_id: uuid.UUID,
-    task_id: uuid.UUID,
-    task_in: TaskUpdate,
-    db: AsyncSession = Depends(get_db_session),
-    current_user=Depends(get_current_user),
-) -> TaskRead:
-    await _ensure_study_exists(db, study_id)
-    task = await task_crud.get(db, task_id)
-    if not task or task.study_id != study_id:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Task not found")
-    if task_in.milestone_id:
-        await _validate_milestone(db, study_id, task_in.milestone_id)
-
-    old_status = task.status
-    updated = await task_crud.update(db, task, task_in)
-    assignee = None
-    if updated.assignee_id:
-        assignee = await user_crud.get_by_id(db, updated.assignee_id)
-    detail = None
-    if task_in.status and task_in.status != old_status:
-        detail = f"task {task_id} status {old_status} -> {task_in.status}"
-    await audit_crud.log_action(
-        db,
-        study_id=study_id,
-        entity_type="task",
-        entity_id=task_id,
-        action="UPDATE_TASK" if not detail else "TASK_STATUS_CHANGE",
-        detail=detail or "Task updated",
-        operator_id=current_user.id,
-        operator_role=current_user.role,
-    )
-    return _to_task_read(updated, assignee)
-
-
-def _to_task_read(task, assignee) -> TaskRead:
-    return TaskRead(
-        id=task.id,
-        study_id=task.study_id,
-        milestone_id=task.milestone_id,
-        title=task.title,
-        description=task.description,
-        assignee_id=task.assignee_id,
-        assignee=UserDisplay.model_validate(assignee) if assignee else None,
-        priority=task.priority,
-        due_date=task.due_date,
-        status=task.status,
-        completed_at=task.completed_at,
-        created_by=task.created_by,
-        created_at=task.created_at,
-        updated_at=task.updated_at,
-    )
@@ -1,2 +0,0 @@
-TASK_STATUS = ["TODO", "DOING", "DONE", "BLOCKED"]
-TASK_PRIORITY = ["LOW", "MEDIUM", "HIGH"]
@@ -1,77 +0,0 @@
-import uuid
-from datetime import datetime, timezone
-from typing import Sequence
-
-from sqlalchemy import select, update as sa_update
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from app.models.task import Task
-from app.schemas.task import TaskCreate, TaskUpdate
-
-
-async def create(
-    db: AsyncSession,
-    study_id: uuid.UUID,
-    task_in: TaskCreate,
-    *,
-    created_by: uuid.UUID,
-) -> Task:
-    task = Task(
-        study_id=study_id,
-        milestone_id=task_in.milestone_id,
-        title=task_in.title,
-        description=task_in.description,
-        assignee_id=task_in.assignee_id,
-        priority=task_in.priority,
-        due_date=task_in.due_date,
-        status="TODO",
-        created_by=created_by,
-    )
-    db.add(task)
-    await db.commit()
-    await db.refresh(task)
-    return task
-
-
-async def get(db: AsyncSession, task_id: uuid.UUID) -> Task | None:
-    result = await db.execute(select(Task).where(Task.id == task_id))
-    return result.scalar_one_or_none()
-
-
-async def list_tasks(
-    db: AsyncSession,
-    study_id: uuid.UUID,
-    milestone_id: uuid.UUID | None = None,
-    assignee_id: uuid.UUID | None = None,
-    status: str | None = None,
-) -> Sequence[Task]:
-    stmt = select(Task).where(Task.study_id == study_id)
-    if milestone_id:
-        stmt = stmt.where(Task.milestone_id == milestone_id)
-    if assignee_id:
-        stmt = stmt.where(Task.assignee_id == assignee_id)
-    if status:
-        stmt = stmt.where(Task.status == status)
-    stmt = stmt.order_by(Task.due_date)
-    result = await db.execute(stmt)
-    return result.scalars().all()
-
-
-async def update(db: AsyncSession, task: Task, task_in: TaskUpdate) -> Task:
-    update_data = task_in.model_dump(exclude_unset=True)
-    if "status" in update_data:
-        status_change = update_data["status"]
-        if status_change == "DONE":
-            update_data["completed_at"] = datetime.now(timezone.utc)
-        else:
-            update_data["completed_at"] = None
-
-    if update_data:
-        await db.execute(
-            sa_update(Task)
-            .where(Task.id == task.id)
-            .values(**update_data)
-        )
-        await db.commit()
-    await db.refresh(task)
-    return task
@@ -9,7 +9,6 @@ from app.models.comment import Comment  # noqa: F401
 from app.models.attachment import Attachment  # noqa: F401
 from app.models.audit_log import AuditLog  # noqa: F401
 from app.models.milestone import Milestone  # noqa: F401
-from app.models.task import Task  # noqa: F401
 from app.models.subject import Subject  # noqa: F401
 from app.models.visit import Visit  # noqa: F401
 from app.models.ae import AdverseEvent  # noqa: F401
@@ -41,7 +41,6 @@ def create_app() -> FastAPI:
            {"name": "attachments", "description": "通用附件"},
            {"name": "audit-logs", "description": "审计日志"},
            {"name": "milestones", "description": "里程碑"},
-            {"name": "tasks", "description": "任务"},
            {"name": "dashboard", "description": "项目总览与统计"},
            {"name": "subjects", "description": "受试者"},
            {"name": "visits", "description": "访视"},
@@ -1,28 +0,0 @@
-import uuid
-from datetime import datetime, date
-
-from sqlalchemy import Date, DateTime, ForeignKey, String, Text, func
-from sqlalchemy.dialects.postgresql import UUID
-from sqlalchemy.orm import Mapped, mapped_column
-
-from app.db.base_class import Base
-
-
-class Task(Base):
-    __tablename__ = "tasks"
-
-    id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
-    study_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("studies.id"), index=True, nullable=False)
-    milestone_id: Mapped[uuid.UUID | None] = mapped_column(UUID(as_uuid=True), ForeignKey("milestones.id"), nullable=True)
-    title: Mapped[str] = mapped_column(String(200), nullable=False)
-    description: Mapped[str | None] = mapped_column(Text, nullable=True)
-    assignee_id: Mapped[uuid.UUID | None] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=True)
-    priority: Mapped[str] = mapped_column(String(20), nullable=False, default="MEDIUM")
-    due_date: Mapped[date | None] = mapped_column(Date, nullable=True)
-    status: Mapped[str] = mapped_column(String(20), nullable=False, default="TODO")
-    completed_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True), nullable=True)
-    created_by: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), ForeignKey("users.id"), nullable=False)
-    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), nullable=False, server_default=func.now())
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, server_default=func.now(), onupdate=func.now()
-    )
@@ -4,7 +4,4 @@ from pydantic import BaseModel
 class StudyProgressRead(BaseModel):
    milestones_total: int
    milestones_done: int
-    tasks_total: int
-    tasks_done: int
-    tasks_overdue: int
    completion_rate: float
@@ -1,45 +0,0 @@
-import uuid
-from datetime import date, datetime
-from typing import Optional
-
-from pydantic import BaseModel, ConfigDict
-
-from app.schemas.user import UserDisplay
-
-
-class TaskCreate(BaseModel):
-    milestone_id: Optional[uuid.UUID] = None
-    title: str
-    description: Optional[str] = None
-    assignee_id: Optional[uuid.UUID] = None
-    priority: str = "MEDIUM"
-    due_date: Optional[date] = None
-
-
-class TaskUpdate(BaseModel):
-    milestone_id: Optional[uuid.UUID] = None
-    title: Optional[str] = None
-    description: Optional[str] = None
-    assignee_id: Optional[uuid.UUID] = None
-    priority: Optional[str] = None
-    due_date: Optional[date] = None
-    status: Optional[str] = None
-
-
-class TaskRead(BaseModel):
-    id: uuid.UUID
-    study_id: uuid.UUID
-    milestone_id: Optional[uuid.UUID]
-    title: str
-    description: Optional[str]
-    assignee_id: Optional[uuid.UUID]
-    assignee: Optional[UserDisplay] = None
-    priority: str
-    due_date: Optional[date]
-    status: str
-    completed_at: Optional[datetime]
-    created_by: uuid.UUID
-    created_at: datetime
-    updated_at: datetime
-
-    model_config = ConfigDict(from_attributes=True)