148 lines
4.6 KiB
Python
148 lines
4.6 KiB
Python
import os
|
|
import shutil
|
|
from fastapi import APIRouter, Depends, HTTPException, status, UploadFile, File, BackgroundTasks
|
|
from sqlalchemy.orm import Session
|
|
from typing import List, Optional
|
|
import uuid
|
|
from app.db.database import get_db
|
|
from app.models.models import Activity, Evidence, User
|
|
from app.security import get_current_active_user
|
|
from app.services.activities import ActivityService
|
|
from app import schemas
|
|
from app.schemas import ActivityCreate, ActivityUpdate
|
|
|
|
router = APIRouter(
|
|
prefix="/activities",
|
|
tags=["Activities"]
|
|
)
|
|
|
|
def get_activity_service(
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_active_user)
|
|
) -> ActivityService:
|
|
return ActivityService(db, current_user)
|
|
|
|
UPLOAD_DIR = "uploads"
|
|
if not os.path.exists(UPLOAD_DIR):
|
|
os.makedirs(UPLOAD_DIR)
|
|
|
|
@router.post("/", response_model=schemas.Activity)
|
|
def create_activity(
|
|
activity: ActivityCreate,
|
|
service: ActivityService = Depends(get_activity_service)
|
|
):
|
|
return service.create_activity(activity)
|
|
|
|
@router.get("/", response_model=List[schemas.Activity])
|
|
def read_activities(
|
|
project_id: Optional[int] = None,
|
|
specialty_id: Optional[int] = None,
|
|
skip: int = 0,
|
|
limit: int = 100,
|
|
service: ActivityService = Depends(get_activity_service)
|
|
):
|
|
db_activities = service.get_activities(project_id, specialty_id, skip, limit)
|
|
return db_activities
|
|
|
|
@router.get("/{activity_id}", response_model=schemas.Activity)
|
|
def read_activity(
|
|
activity_id: int,
|
|
service: ActivityService = Depends(get_activity_service)
|
|
):
|
|
return service.get_activity(activity_id)
|
|
|
|
@router.put("/{activity_id}", response_model=schemas.Activity)
|
|
def update_activity(
|
|
activity_id: int,
|
|
activity: schemas.ActivityUpdate,
|
|
service: ActivityService = Depends(get_activity_service)
|
|
):
|
|
db_activity = service.update_activity(activity_id, activity)
|
|
return db_activity
|
|
|
|
@router.post("/{activity_id}/upload", response_model=schemas.Evidence)
|
|
async def upload_evidence(
|
|
activity_id: int,
|
|
background_tasks: BackgroundTasks,
|
|
file: UploadFile = File(...),
|
|
description: Optional[str] = None,
|
|
captured_at: Optional[str] = None,
|
|
service: ActivityService = Depends(get_activity_service)
|
|
):
|
|
|
|
db_evidence = service.upload_evidence(
|
|
activity_id,
|
|
background_tasks,
|
|
file,
|
|
description,
|
|
captured_at
|
|
)
|
|
|
|
return db_evidence
|
|
|
|
@router.post("/evidence/{evidence_id}/retry-transcription", response_model=schemas.Evidence)
|
|
async def retry_transcription(
|
|
evidence_id: int,
|
|
background_tasks: BackgroundTasks,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_active_user)
|
|
):
|
|
db_evidence = db.query(Evidence).filter(Evidence.id == evidence_id).first()
|
|
if not db_evidence:
|
|
raise HTTPException(status_code=404, detail="Evidence not found")
|
|
|
|
if not db_evidence.media_type or "audio" not in db_evidence.media_type:
|
|
raise HTTPException(status_code=400, detail="Only audio evidence can be transcribed")
|
|
|
|
# Update status to pending
|
|
db_evidence.transcription_status = "pending"
|
|
db_evidence.transcription = None
|
|
db.commit()
|
|
db.refresh(db_evidence)
|
|
|
|
# Queue transcription task
|
|
from app.services.transcription_worker import process_transcription
|
|
background_tasks.add_task(process_transcription, db_evidence.id)
|
|
|
|
return db_evidence
|
|
|
|
@router.put("/evidence/{evidence_id}", response_model=schemas.Evidence)
|
|
def update_evidence(
|
|
evidence_id: int,
|
|
evidence: schemas.EvidenceUpdate,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_active_user)
|
|
):
|
|
db_evidence = db.query(Evidence).filter(Evidence.id == evidence_id).first()
|
|
if not db_evidence:
|
|
raise HTTPException(status_code=404, detail="Evidence not found")
|
|
|
|
update_data = evidence.dict(exclude_unset=True)
|
|
for key, value in update_data.items():
|
|
setattr(db_evidence, key, value)
|
|
|
|
db.commit()
|
|
db.refresh(db_evidence)
|
|
return db_evidence
|
|
|
|
@router.delete("/evidence/{evidence_id}")
|
|
def delete_evidence(
|
|
evidence_id: int,
|
|
db: Session = Depends(get_db),
|
|
current_user: User = Depends(get_current_active_user)
|
|
):
|
|
db_evidence = db.query(Evidence).filter(Evidence.id == evidence_id).first()
|
|
if not db_evidence:
|
|
raise HTTPException(status_code=404, detail="Evidence not found")
|
|
|
|
# Optional: Delete file from disk
|
|
if db_evidence.file_path and os.path.exists(db_evidence.file_path):
|
|
try:
|
|
os.remove(db_evidence.file_path)
|
|
except:
|
|
pass
|
|
|
|
db.delete(db_evidence)
|
|
db.commit()
|
|
return {"detail": "Evidence deleted"}
|