Project

@router.post("/project/", response_model=ProjectRead, status_code=201)
async def create_project(
    project: ProjectCreate,
    user: UserOAuth = Depends(get_api_user),
    db: AsyncSession = Depends(get_async_db),
) -> ProjectV2:
    """
    Create new project
    """

    # Get validated resource and profile
    resource, profile = await validate_user_profile(
        user=user,
        db=db,
    )
    resource_id = resource.id

    # Check that there is no project with the same user and name
    await _check_project_exists(
        project_name=project.name, user_id=user.id, db=db
    )

    db_project = ProjectV2(**project.model_dump(), resource_id=resource_id)
    db.add(db_project)
    await db.flush()

    link = LinkUserProjectV2(
        project_id=db_project.id,
        user_id=user.id,
        is_owner=True,
        is_verified=True,
        permissions=ProjectPermissions.EXECUTE,
    )
    db.add(link)

    await db.commit()
    await db.refresh(db_project)

    return db_project

@router.delete("/project/{project_id}/", status_code=204)
async def delete_project(
    project_id: int,
    user: UserOAuth = Depends(get_api_user),
    db: AsyncSession = Depends(get_async_db),
) -> Response:
    """
    Delete project
    """

    project = await _get_project_check_access(
        project_id=project_id,
        user_id=user.id,
        required_permissions=ProjectPermissions.EXECUTE,
        db=db,
    )
    link_user_project = await db.get(LinkUserProjectV2, (project_id, user.id))
    if not link_user_project.is_owner:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Only the owner can delete a Project.",
        )

    # Fail if there exist jobs that are submitted and in relation with the
    # current project.
    stm = _get_submitted_jobs_statement().where(JobV2.project_id == project_id)
    res = await db.execute(stm)
    jobs = res.scalars().all()
    if jobs:
        string_ids = str([job.id for job in jobs])[1:-1]
        raise HTTPException(
            status_code=status.HTTP_422_UNPROCESSABLE_CONTENT,
            detail=(
                f"Cannot delete project {project.id} because it "
                f"is linked to active job(s) {string_ids}."
            ),
        )

    logger.debug(f"Add project {project.id} to deletion.")
    await db.delete(project)

    logger.debug("Commit changes to db")
    await db.commit()

    logger.debug("Everything  has been deleted correctly.")

    return Response(status_code=status.HTTP_204_NO_CONTENT)

@router.get("/project/", response_model=list[ProjectRead])
async def get_list_project(
    is_owner: bool = True,
    user: UserOAuth = Depends(get_api_guest),
    db: AsyncSession = Depends(get_async_db),
) -> Sequence[ProjectV2]:
    """
    Return list of projects user is member of
    """
    stm = (
        select(ProjectV2)
        .join(LinkUserProjectV2, LinkUserProjectV2.project_id == ProjectV2.id)
        .where(LinkUserProjectV2.user_id == user.id)
        .where(LinkUserProjectV2.is_owner == is_owner)
        .where(LinkUserProjectV2.is_verified.is_(True))
        .order_by(
            ProjectV2.is_starred.desc(),
            ProjectV2.timestamp_created.desc(),
        )
    )
    res = await db.execute(stm)
    project_list = res.scalars().all()
    return project_list

@router.get("/project/{project_id}/", response_model=ProjectRead)
async def read_project(
    project_id: int,
    user: UserOAuth = Depends(get_api_guest),
    db: AsyncSession = Depends(get_async_db),
) -> ProjectV2:
    """
    Return info on an existing project
    """
    project = await _get_project_check_access(
        project_id=project_id,
        user_id=user.id,
        required_permissions=ProjectPermissions.READ,
        db=db,
    )
    return project

@router.post(
    "/project/{project_id}/star/",
    status_code=status.HTTP_200_OK,
)
async def star_project(
    project_id: int,
    user: UserOAuth = Depends(get_api_user),
    db: AsyncSession = Depends(get_async_db),
) -> Response:
    """
    Set `ProjectV2.is_starred` to `True`
    """
    project = await _get_project_check_access(
        project_id=project_id,
        user_id=user.id,
        required_permissions=ProjectPermissions.WRITE,
        db=db,
    )
    project.is_starred = True
    db.add(project)
    await db.commit()
    return Response(status_code=status.HTTP_200_OK)

@router.post(
    "/project/{project_id}/unstar/",
    status_code=status.HTTP_200_OK,
)
async def unstar_project(
    project_id: int,
    user: UserOAuth = Depends(get_api_user),
    db: AsyncSession = Depends(get_async_db),
) -> Response:
    """
    Set `ProjectV2.is_starred` to `False`
    """
    project = await _get_project_check_access(
        project_id=project_id,
        user_id=user.id,
        required_permissions=ProjectPermissions.WRITE,
        db=db,
    )
    project.is_starred = False
    db.add(project)
    await db.commit()
    return Response(status_code=status.HTTP_200_OK)