Step 3：Study / Site / StudyMember + 项目权限

backend/app/crud/member.py

@@ -0,0 +1,64 @@
+import uuid
+from typing import Sequence
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.study_member import StudyMember
+from app.schemas.member import StudyMemberCreate, StudyMemberUpdate
+
+
+async def get_member(db: AsyncSession, study_id: uuid.UUID, user_id: uuid.UUID) -> StudyMember | None:
+    result = await db.execute(
+        select(StudyMember).where(StudyMember.study_id == study_id, StudyMember.user_id == user_id)
+    )
+    return result.scalar_one_or_none()
+
+
+async def get_member_by_id(db: AsyncSession, member_id: uuid.UUID) -> StudyMember | None:
+    result = await db.execute(select(StudyMember).where(StudyMember.id == member_id))
+    return result.scalar_one_or_none()
+
+
+async def add_member(db: AsyncSession, study_id: uuid.UUID, member_in: StudyMemberCreate) -> StudyMember:
+    member = StudyMember(
+        study_id=study_id,
+        user_id=member_in.user_id,
+        role_in_study=member_in.role_in_study,
+        is_active=member_in.is_active,
+    )
+    db.add(member)
+    await db.commit()
+    await db.refresh(member)
+    return member
+
+
+async def list_members(db: AsyncSession, study_id: uuid.UUID, skip: int = 0, limit: int = 100) -> Sequence[StudyMember]:
+    result = await db.execute(
+        select(StudyMember).where(StudyMember.study_id == study_id).offset(skip).limit(limit)
+    )
+    return result.scalars().all()
+
+
+async def update_member(db: AsyncSession, member: StudyMember, member_in: StudyMemberUpdate) -> StudyMember:
+    update_data = {k: v for k, v in member_in.model_dump(exclude_unset=True).items() if v is not None}
+    if update_data:
+        await db.execute(
+            update(StudyMember)
+            .where(StudyMember.id == member.id)
+            .values(**update_data)
+        )
+        await db.commit()
+    await db.refresh(member)
+    return member
+
+
+async def remove_member(db: AsyncSession, member: StudyMember) -> StudyMember:
+    await db.execute(
+        update(StudyMember)
+        .where(StudyMember.id == member.id)
+        .values(is_active=False)
+    )
+    await db.commit()
+    await db.refresh(member)
+    return member

backend/app/crud/site.py

@@ -0,0 +1,48 @@
+import uuid
+from typing import Sequence
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.site import Site
+from app.schemas.site import SiteCreate, SiteUpdate
+
+
+async def create_site(db: AsyncSession, study_id: uuid.UUID, site_in: SiteCreate) -> Site:
+    site = Site(
+        study_id=study_id,
+        name=site_in.name,
+        city=site_in.city,
+        pi_name=site_in.pi_name,
+        contact=site_in.contact,
+        is_active=site_in.is_active,
+    )
+    db.add(site)
+    await db.commit()
+    await db.refresh(site)
+    return site
+
+
+async def get_site(db: AsyncSession, site_id: uuid.UUID) -> Site | None:
+    result = await db.execute(select(Site).where(Site.id == site_id))
+    return result.scalar_one_or_none()
+
+
+async def update_site(db: AsyncSession, site: Site, site_in: SiteUpdate) -> Site:
+    update_data = site_in.model_dump(exclude_unset=True)
+    if update_data:
+        await db.execute(
+            update(Site)
+            .where(Site.id == site.id)
+            .values(**update_data)
+        )
+        await db.commit()
+    await db.refresh(site)
+    return site
+
+
+async def list_by_study(db: AsyncSession, study_id: uuid.UUID, skip: int = 0, limit: int = 100) -> Sequence[Site]:
+    result = await db.execute(
+        select(Site).where(Site.study_id == study_id).offset(skip).limit(limit)
+    )
+    return result.scalars().all()

backend/app/crud/study.py

@@ -0,0 +1,71 @@
+import uuid
+from typing import Sequence
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.study import Study
+from app.schemas.study import StudyCreate, StudyUpdate
+
+
+async def create(db: AsyncSession, study_in: StudyCreate, *, created_by: uuid.UUID | None = None) -> Study:
+    study = Study(
+        code=study_in.code,
+        name=study_in.name,
+        sponsor=study_in.sponsor,
+        protocol_no=study_in.protocol_no,
+        phase=study_in.phase,
+        status=study_in.status,
+        created_by=created_by,
+    )
+    db.add(study)
+    await db.commit()
+    await db.refresh(study)
+    return study
+
+
+async def get(db: AsyncSession, study_id: uuid.UUID) -> Study | None:
+    result = await db.execute(select(Study).where(Study.id == study_id))
+    return result.scalar_one_or_none()
+
+
+async def get_by_code(db: AsyncSession, code: str) -> Study | None:
+    result = await db.execute(select(Study).where(Study.code == code))
+    return result.scalar_one_or_none()
+
+
+async def update(db: AsyncSession, study: Study, study_in: StudyUpdate) -> Study:
+    update_data = study_in.model_dump(exclude_unset=True)
+    if update_data:
+        await db.execute(
+            update(Study)
+            .where(Study.id == study.id)
+            .values(**update_data)
+        )
+        await db.commit()
+    await db.refresh(study)
+    return study
+
+
+async def list_studies(db: AsyncSession, skip: int = 0, limit: int = 100) -> Sequence[Study]:
+    result = await db.execute(select(Study).offset(skip).limit(limit))
+    return result.scalars().all()
+
+
+async def list_studies_for_user(
+    db: AsyncSession,
+    user_id: uuid.UUID,
+    skip: int = 0,
+    limit: int = 100,
+) -> Sequence[Study]:
+    from app.models.study_member import StudyMember  # local import to avoid cycles
+
+    stmt = (
+        select(Study)
+        .join(StudyMember, StudyMember.study_id == Study.id)
+        .where(StudyMember.user_id == user_id, StudyMember.is_active.is_(True))
+        .offset(skip)
+        .limit(limit)
+    )
+    result = await db.execute(stmt)
+    return result.scalars().all()