Ændre eller lav en ny endpoint

[maxumi]

For get get_active_questionnaire i endpoint bruger det et bruger id til at få fat i et active questionaire og give det tilbage. Et problem nu er hvis man ikke har det så vil det give fejl.

Mulig måder du kan gøre

@router.get(
    path="/questionnaire/active/check/{user_id}",
    tags=["questionnaire"],
    response_model=Union[schemas.ActiveQuestionnaireModel, bool],
)
def check_active_questionnaire_for_user(
    request: Request,
    user_id: str,  # The ID of the user
    db: Annotated[Session, Depends(get_db)],
) -> Union[schemas.ActiveQuestionnaireModel, bool]:
    active_questionnaire: Optional[models.ActiveQuestionnaire] = (
        crud.get_active_questionnaire_by_user_id(db=db, user_id=user_id)
    )
    if active_questionnaire is None:
        return False
    return active_questionnaire

# Endpoint 2: Retrieve an active questionnaire by its unique ID
@router.get(
    path="/questionnaire/active/{id}",
    tags=["questionnaire"],
    response_model=schemas.ActiveQuestionnaireModel,
)
def get_active_questionnaire_by_id(
    request: Request,
    id: str,  # The unique ID of the active questionnaire
    db: Annotated[Session, Depends(get_db)],
) -> models.ActiveQuestionnaire:
    active_questionnaire: Optional[models.ActiveQuestionnaire] = (
        crud.get_active_questionnaire_by_id(db=db, id=id)
    )
    if active_questionnaire is None:
        raise HTTPException(status_code=404, detail="Active questionnaire not found")
    return active_questionnaire

Crud

def get_active_questionnaire_by_user_id(
    db: Session,
    user_id: str,
) -> Optional[models.ActiveQuestionnaire]:
    db.flush()
    result = db.execute(
        select(models.ActiveQuestionnaire).where(
            (models.ActiveQuestionnaire.student_id == user_id) | 
            (models.ActiveQuestionnaire.teacher_id == user_id)
        )
    )
    return result.scalars().first()

def get_active_questionnaire_by_user_id(
    db: Session,
    user_id: str,
) -> Optional[models.ActiveQuestionnaire]:
    db.flush()
    result: Result[Tuple[models.ActiveQuestionnaire]] = db.execute(
        statement=select(models.ActiveQuestionnaire).where(
            models.ActiveQuestionnaire.student.has(id=user_id)
        )
    )
    return result.scalars().first()

[LobaDK]

@router.get(
    path="/questionnaire/active/{user_id}",
    tags=["questionnaire"],
    response_model=schemas.ActiveQuestionnaireModel,
)
def get_active_questionnaire(
    request: Request,
    user_id: str,
    db: Annotated[Session, Depends(dependency=get_db)],
) -> models.ActiveQuestionnaire:
    questionnaire: Optional[models.ActiveQuestionnaire] = (
        crud.get_active_questionnaire_by_user_id(db=db, user_id=user_id)
    )
    if questionnaire is None:
        raise HTTPException(status_code=404, detail="Questionnaire not found")
    return questionnaire

@router.get(
    path="/questionnaire/active/{user_id}/exists",
    tags=["questionnaire"],
    response_model=QuestionnaireExistsResponse(),
)
def check_if_user_has_active_questionnaire(
    request: Request,
    user_id: str,
    db: Annotated[Session, Depends(dependency=get_db)],
) -> QuestionnaireExistsResponse:
    questionnaire_exists: bool = questionnaire_id_exists(db=db, id=user_id)
    return QuestionnaireExistsResponse(exists=questionnaire_exists)

/questionnaire/active/{user_id}/exists vil returnere { exists: boolean }, hvor clienten kan så vælge om den vil lave en query på hele questionnairen, som fortsat vil raise 404 Not Found hvis ingen questionnaire blev fundet.

@maxumi

[LobaDK]

backend\lib\api\questionnaire\routes.py

@router.get(
    path="/questionnaire/active/{questionnaire_id}",
    tags=["questionnaire"],
    response_model=schemas.ActiveQuestionnaireModel,
)
def get_active_questionnaire(
    request: Request,
    questionnaire_id: str,
    db: Annotated[Session, Depends(dependency=get_db)],
) -> models.ActiveQuestionnaire:
    questionnaire: Optional[models.ActiveQuestionnaire] = (
        crud.get_active_questionnaire_by_id(db=db, questionnaire_id=questionnaire_id)
    )
    if questionnaire is None:
        raise HTTPException(status_code=404, detail="Questionnaire not found")
    return questionnaire

@router.get(
    path="/questionnaire/active/check/{user_id}",
    tags=["questionnaire"],
    response_model=Optional[str],
)
def check_if_user_has_active_questionnaires(
    request: Request,
    user_id: str,
    db: Annotated[Session, Depends(dependency=get_db)],
) -> Optional[str]:
    return crud.get_oldest_active_questionnaire_id_for_user(db=db, user_id=user_id)

@router.get(
    path="/questionnaire/active/check-all/{user_id}",
    tags=["questionnaire"],
    response_model=Sequence[str],
)
def check_all_active_questionnaires_for_user(
    request: Request,
    user_id: str,
    db: Annotated[Session, Depends(dependency=get_db)],
) -> Sequence[str]:
    return crud.get_all_active_questionnaire_ids_for_user(db=db, user_id=user_id)

backend\lib\sql\crud.py

def user_id_condition(user_id: str) -> ColumnElement[bool]:
    return or_(
        models.ActiveQuestionnaire.student.has(id=user_id),
        models.ActiveQuestionnaire.teacher.has(id=user_id),
    )

def get_active_questionnaire_by_id(
    db: Session,
    questionnaire_id: str,
) -> Optional[models.ActiveQuestionnaire]:
    db.flush()
    result: Result[Tuple[models.ActiveQuestionnaire]] = db.execute(
        statement=select(models.ActiveQuestionnaire).where(
            models.ActiveQuestionnaire.id == questionnaire_id
        )
    )
    return result.scalars().first()

def get_oldest_active_questionnaire_id_for_user(
    db: Session,
    user_id: str,
) -> Optional[str]:
    db.flush()
    result: Result[Tuple[str]] = db.execute(
        statement=select(models.ActiveQuestionnaire.id)
        .where(user_id_condition(user_id=user_id))
        .order_by(models.ActiveQuestionnaire.created_at)
    )
    return result.scalars().first()

def get_all_active_questionnaire_ids_for_user(
    db: Session,
    user_id: str,
) -> Sequence[str]:
    db.flush()
    result: Result[Tuple[str]] = db.execute(
        statement=select(models.ActiveQuestionnaire.id)
        .where(user_id_condition(user_id=user_id))
        .order_by(models.ActiveQuestionnaire.created_at)
    )
    return result.scalars().all()

@maxumi