管理后台前后端逻辑、UI美化

This commit is contained in:
Cheng Zhou
2026-01-16 13:50:08 +08:00
parent 05c1f9579a
commit 7fdcfdaadd
82 changed files with 3210 additions and 549 deletions
+312 -6
View File
@@ -1,12 +1,42 @@
import uuid
from typing import Sequence
from pathlib import Path
from typing import Iterable, Sequence
from sqlalchemy import select, update
from sqlalchemy import delete, or_, select, update
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.acknowledgement import Acknowledgement
from app.models.ae import AdverseEvent
from app.models.attachment import Attachment
from app.models.contract_fee import ContractFee
from app.models.contract_fee_payment import ContractFeePayment
from app.models.document import Document
from app.models.document_version import DocumentVersion
from app.models.distribution import Distribution
from app.models.drug_shipment import DrugShipment
from app.models.fee_attachment import FeeAttachment
from app.models.finance import FinanceItem
from app.models.finance_contract import FinanceContract
from app.models.finance_special import FinanceSpecial
from app.models.kickoff_meeting import KickoffMeeting
from app.models.knowledge_note import KnowledgeNote
from app.models.milestone import Milestone
from app.models.site import Site
from app.models.special_expense import SpecialExpense
from app.models.startup_ethics import StartupEthics
from app.models.startup_feasibility import StartupFeasibility
from app.models.subject import Subject
from app.models.subject_history import SubjectHistory
from app.models.training_authorization import TrainingAuthorization
from app.models.version_workflow import VersionWorkflow
from app.models.visit import Visit
from app.models.workflow_action import WorkflowAction
from app.schemas.site import SiteCreate, SiteUpdate
ATTACHMENT_ROOT = Path(__file__).resolve().parent.parent / "uploads"
FEE_ATTACHMENT_ROOT = ATTACHMENT_ROOT / "fees"
DOCUMENT_ATTACHMENT_ROOT = ATTACHMENT_ROOT / "documents"
async def create_site(db: AsyncSession, study_id: uuid.UUID, site_in: SiteCreate) -> Site:
site = Site(
@@ -41,10 +71,17 @@ async def update_site(db: AsyncSession, site: Site, site_in: SiteUpdate) -> 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)
)
async def list_by_study(
db: AsyncSession,
study_id: uuid.UUID,
skip: int = 0,
limit: int = 100,
include_inactive: bool = False,
) -> Sequence[Site]:
stmt = select(Site).where(Site.study_id == study_id)
if not include_inactive:
stmt = stmt.where(Site.is_active.is_(True))
result = await db.execute(stmt.offset(skip).limit(limit))
return result.scalars().all()
@@ -54,3 +91,272 @@ async def get_sites_by_ids(db: AsyncSession, ids: set[uuid.UUID]) -> dict[uuid.U
result = await db.execute(select(Site).where(Site.id.in_(ids)))
sites = result.scalars().all()
return {s.id: s for s in sites}
async def list_active_names(db: AsyncSession, study_id: uuid.UUID) -> set[str]:
result = await db.execute(
select(Site.name).where(Site.study_id == study_id, Site.is_active.is_(True))
)
return {row[0] for row in result.all() if row[0]}
async def delete_site_and_related(db: AsyncSession, site: Site) -> None:
site_id = site.id
study_id = site.study_id
site_name = site.name
subject_ids = (
await db.execute(select(Subject.id).where(Subject.site_id == site_id))
).scalars().all()
contract_fee_ids = (
await db.execute(select(ContractFee.id).where(ContractFee.center_id == site_id))
).scalars().all()
special_expense_ids = (
await db.execute(select(SpecialExpense.id).where(SpecialExpense.center_id == site_id))
).scalars().all()
drug_shipment_ids = (
await db.execute(select(DrugShipment.id).where(DrugShipment.center_id == site_id))
).scalars().all()
kickoff_ids = (
await db.execute(select(KickoffMeeting.id).where(KickoffMeeting.site_id == site_id))
).scalars().all()
feasibility_ids = (
await db.execute(select(StartupFeasibility.id).where(StartupFeasibility.site_id == site_id))
).scalars().all()
ethics_ids = (
await db.execute(select(StartupEthics.id).where(StartupEthics.site_id == site_id))
).scalars().all()
training_ids = (
await db.execute(
select(TrainingAuthorization.id).where(
TrainingAuthorization.study_id == study_id,
TrainingAuthorization.site_name == site_name,
)
)
).scalars().all()
finance_contract_ids = (
await db.execute(
select(FinanceContract.id).where(
FinanceContract.study_id == study_id,
FinanceContract.site_name == site_name,
)
)
).scalars().all()
finance_special_ids = (
await db.execute(
select(FinanceSpecial.id).where(
FinanceSpecial.study_id == study_id,
FinanceSpecial.site_name == site_name,
)
)
).scalars().all()
knowledge_note_ids = (
await db.execute(
select(KnowledgeNote.id).where(
KnowledgeNote.study_id == study_id,
KnowledgeNote.site_name == site_name,
)
)
).scalars().all()
document_ids = (
await db.execute(select(Document.id).where(Document.site_id == site_id))
).scalars().all()
version_ids = []
if document_ids:
version_ids = (
await db.execute(select(DocumentVersion.id).where(DocumentVersion.document_id.in_(document_ids)))
).scalars().all()
workflow_ids = []
workflow_conditions = []
if document_ids:
workflow_conditions.append(VersionWorkflow.document_id.in_(document_ids))
if version_ids:
workflow_conditions.append(VersionWorkflow.version_id.in_(version_ids))
if workflow_conditions:
workflow_ids = (
await db.execute(select(VersionWorkflow.id).where(or_(*workflow_conditions)))
).scalars().all()
distribution_conditions = []
if document_ids:
distribution_conditions.append(Distribution.document_id.in_(document_ids))
if version_ids:
distribution_conditions.append(Distribution.version_id.in_(version_ids))
distribution_conditions.append((Distribution.target_type == "SITE") & (Distribution.target_id == str(site_id)))
distribution_ids = (
await db.execute(select(Distribution.id).where(or_(*distribution_conditions)))
).scalars().all()
attachment_groups: dict[str, list[uuid.UUID]] = {
"startup_feasibility": feasibility_ids,
"startup_ethics": ethics_ids,
"startup_kickoff": kickoff_ids,
"startup_kickoff_minutes": kickoff_ids,
"startup_kickoff_signin": kickoff_ids,
"startup_kickoff_ppt": kickoff_ids,
"training_authorization": training_ids,
"finance_contract": finance_contract_ids,
"finance_special": finance_special_ids,
"knowledge_note": knowledge_note_ids,
"drug_shipment": drug_shipment_ids,
}
attachment_paths: list[str] = []
for entity_type, ids in attachment_groups.items():
if not ids:
continue
attachment_paths.extend(
(
await db.execute(
select(Attachment.file_path).where(
Attachment.study_id == study_id,
Attachment.entity_type == entity_type,
Attachment.entity_id.in_(ids),
)
)
).scalars().all()
)
await db.execute(
delete(Attachment).where(
Attachment.study_id == study_id,
Attachment.entity_type == entity_type,
Attachment.entity_id.in_(ids),
)
)
fee_attachment_paths: list[str] = []
if contract_fee_ids:
fee_attachment_paths.extend(
(
await db.execute(
select(FeeAttachment.storage_key).where(
FeeAttachment.entity_type == "contract_fee",
FeeAttachment.entity_id.in_(contract_fee_ids),
)
)
).scalars().all()
)
await db.execute(
delete(FeeAttachment).where(
FeeAttachment.entity_type == "contract_fee",
FeeAttachment.entity_id.in_(contract_fee_ids),
)
)
await db.execute(delete(ContractFeePayment).where(ContractFeePayment.contract_fee_id.in_(contract_fee_ids)))
if special_expense_ids:
fee_attachment_paths.extend(
(
await db.execute(
select(FeeAttachment.storage_key).where(
FeeAttachment.entity_type == "special_expense",
FeeAttachment.entity_id.in_(special_expense_ids),
)
)
).scalars().all()
)
await db.execute(
delete(FeeAttachment).where(
FeeAttachment.entity_type == "special_expense",
FeeAttachment.entity_id.in_(special_expense_ids),
)
)
if workflow_ids:
await db.execute(delete(WorkflowAction).where(WorkflowAction.workflow_id.in_(workflow_ids)))
await db.execute(delete(VersionWorkflow).where(VersionWorkflow.id.in_(workflow_ids)))
if distribution_ids:
await db.execute(delete(Acknowledgement).where(Acknowledgement.distribution_id.in_(distribution_ids)))
await db.execute(delete(Distribution).where(Distribution.id.in_(distribution_ids)))
await db.execute(delete(Acknowledgement).where(Acknowledgement.site_id == site_id))
version_file_paths: list[str] = []
if version_ids:
version_file_paths = (
await db.execute(select(DocumentVersion.file_uri).where(DocumentVersion.id.in_(version_ids)))
).scalars().all()
await db.execute(delete(DocumentVersion).where(DocumentVersion.id.in_(version_ids)))
if document_ids:
await db.execute(delete(Document).where(Document.id.in_(document_ids)))
if subject_ids:
await db.execute(delete(SubjectHistory).where(SubjectHistory.subject_id.in_(subject_ids)))
await db.execute(delete(Visit).where(Visit.subject_id.in_(subject_ids)))
await db.execute(delete(AdverseEvent).where(AdverseEvent.subject_id.in_(subject_ids)))
await db.execute(delete(FinanceItem).where(FinanceItem.subject_id.in_(subject_ids)))
await db.execute(delete(AdverseEvent).where(AdverseEvent.site_id == site_id))
await db.execute(delete(FinanceItem).where(FinanceItem.site_id == site_id))
await db.execute(delete(Subject).where(Subject.site_id == site_id))
await db.execute(delete(Milestone).where(Milestone.site_id == site_id))
await db.execute(delete(KickoffMeeting).where(KickoffMeeting.site_id == site_id))
await db.execute(delete(StartupFeasibility).where(StartupFeasibility.site_id == site_id))
await db.execute(delete(StartupEthics).where(StartupEthics.site_id == site_id))
await db.execute(delete(ContractFee).where(ContractFee.center_id == site_id))
await db.execute(delete(SpecialExpense).where(SpecialExpense.center_id == site_id))
await db.execute(delete(DrugShipment).where(DrugShipment.center_id == site_id))
await db.execute(
delete(TrainingAuthorization).where(
TrainingAuthorization.study_id == study_id,
TrainingAuthorization.site_name == site_name,
)
)
await db.execute(
delete(FinanceContract).where(
FinanceContract.study_id == study_id,
FinanceContract.site_name == site_name,
)
)
await db.execute(
delete(FinanceSpecial).where(
FinanceSpecial.study_id == study_id,
FinanceSpecial.site_name == site_name,
)
)
await db.execute(
delete(KnowledgeNote).where(
KnowledgeNote.study_id == study_id,
KnowledgeNote.site_name == site_name,
)
)
await db.execute(delete(Site).where(Site.id == site_id))
await _remove_files(attachment_paths, ATTACHMENT_ROOT)
await _remove_files(fee_attachment_paths, FEE_ATTACHMENT_ROOT)
await _remove_files(version_file_paths, DOCUMENT_ATTACHMENT_ROOT)
await db.commit()
async def _remove_files(paths: Iterable[str | None], root: Path) -> None:
for raw in paths:
if not raw:
continue
file_path = Path(str(raw))
try:
if file_path.exists():
file_path.unlink()
except OSError:
pass
_prune_empty_parents(file_path.parent, root)
def _prune_empty_parents(start: Path, root: Path) -> None:
try:
root_resolved = root.resolve()
except OSError:
return
try:
current = start.resolve()
except OSError:
return
if root_resolved not in current.parents and current != root_resolved:
return
while True:
if current == root_resolved:
break
try:
current.rmdir()
except OSError:
break
current = current.parent