def all_channel(current_user=Security(deps.get_current_active_user,
scopes=["read_channel"]),
db: Session = Depends(deps.get_db)):
return crud_channel.get_all_channel_db(db=db)
from fastapi import APIRouter, Depends, Security
from rubrix.server.security import auth
from .model import ApiInfo, ApiStatus
from .service import ApiInfoService, create_info_service
router = APIRouter(tags=["status"])
@router.get(
"/_status",
operation_id="api_status",
response_model=ApiStatus,
dependencies=[Security(auth.get_user, scopes=[])],
)
def api_status(
service: ApiInfoService = Depends(create_info_service),
) -> ApiStatus:
"""
Parameters
----------
service:
The Api info service
Returns
-------
The detailed api status
"""
def __call__(self, api_key: str = Security(API_KEY_HEADER)):
if api_key != self.settings.API_KEY:
raise HTTPException(status_code=HTTP_403_FORBIDDEN,
detail="Could not validate credentials")
def replace_user(uid: str,
user: NewUser,
current_user: User = Security(get_current_user),
if_match: Optional[str] = Header(None)):
return services.users.update(current_user, user, uid, etag=if_match)
def View_all_tag(
current_user= Security(deps.get_current_active_user,scopes=["URL"]),
db: Session = Depends(deps.get_db)
):
return crud_tag.tags(db=db)
async def get_current_active_user(current_user: UserBase = Security(
get_current_user, scopes=["me"])):
if current_user.disabled:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST,
detail="Inactive user")
return current_user
async def read_own_items(
current_user: User = Security(get_current_active_user, scopes=["items"])
):
return [{"item_id": "Foo", "owner": current_user.username}]
async def delete_study(
study_id: str,
current_user: User = Security(get_current_active_user, scopes=["projects"]),
):
_data = {"project_id": study_id, "owner": current_user.username}
return None
async def list_studies(
current_user: User = Security(get_current_active_user, scopes=["projects"])
):
return [{"project_id": "Foo", "owner": current_user.username}]
async def create_study(
current_user: User = Security(get_current_active_user, scopes=["projects"])
):
return {"project_id": "Foo", "owner": current_user.username}
async def replace_study(
study_id: str,
current_user: User = Security(get_current_active_user, scopes=["projects"]),
):
return {"project_id": study_id, "owner": current_user.username}
def all_channel_manager(channel_id: str,
current_user=Security(deps.get_current_active_user,
scopes=["read_channel"]),
db: Session = Depends(deps.get_db)):
return crud_user.get_all_channel_manager(db=db, channel_id=channel_id)
def Count_shop_of_channel(channel_id: str,
current_user=Security(deps.get_current_active_user,
scopes=["read_channel"]),
db: Session = Depends(deps.get_db)):
return crud_shop.count_shop(db=db, channel_id=channel_id)
def channel_detail(channel_id: str,
current_user=Security(deps.get_current_active_user,
scopes=["read_channel"]),
db: Session = Depends(deps.get_db)):
return crud_channel.get_channel(db=db, channel_id=channel_id)
def get_current_user(oauth_header: str = Security(api_key)):
user = User(username=oauth_header)
return user
def view_my_user_info(auth0_user: Optional[Auth0User] = Security(
guest_auth.get_user)):
return view_user_info(auth0_user.id, auth0_user)
result_set_id=result_set_id)
response.headers["Cache-Control"] = "public, max-age=604800, immutable"
except ResultSetNotFound as ex:
raise HTTPException(status_code=HTTP_404_NOT_FOUND,
detail=str(ex)) from ex
if result_format == schemas.ResultSetFormat.csv:
return Response(content=result_set.to_api_schema().to_csv(),
media_type="text/csv")
return result_set
@RESULT_SETS_ROUTER.post(
"/result_set",
response_model=schemas.ResultSet,
status_code=HTTP_201_CREATED,
dependencies=[Security(deps.api_key)],
)
def create_result_set(
*,
db_session: Session = Depends(deps.db_session),
result_set_notifier: ResultSetNotifier = Depends(deps.result_set_notifier),
result_set_crud: CRUDResultSet = Depends(deps.result_set_crud),
result_set_in: schemas.ResultSetCreate,
) -> Any:
"""Create a ResultSet"""
try:
result_set = result_set_crud.create(db_session, obj_in=result_set_in)
if result_set.results:
if result_set_in.job.notify_if_results:
result_set_notification = schemas.ResultSetNotification(
job=result_set_in.job,
async def get_api_key(api_key_query: str = Security(api_key_query)):
if api_key_query == API_KEY:
return api_key_query
else:
raise HTTPException(status_cod=HTTP_403_FORBIDDEN,
detail="Could not validate credentials")
async def get_current_active_user(
current_user: User = Security(get_current_user, scopes=["me"])
):
if current_user.disabled:
raise HTTPException(status_code=400, detail="Inactive user")
return current_user
def get_current_user(oauth_header: Optional[str] = Security(reusable_oauth2)):
if oauth_header is None:
return None
user = User(username=oauth_header)
return user
def read_users(current_user: User = Security(get_current_user)):
results = services.users.retrieve_multiple(current_user)
return list(results)
def get_current_active_user(current_user: User = Security(get_current_user)):
if not crud_user.user.is_active(current_user):
raise HTTPException(status_code=400, detail="Inactive user")
return current_user
def create_user(user: NewUser,
current_user: User = Security(get_current_user)):
return services.users.create(current_user, user)
def get_current_active_superuser(current_user: User = Security(get_current_user)):
if not crud_user.user.is_superuser(current_user):
raise HTTPException(
status_code=400, detail="The user doesn't have enough privileges"
)
return current_user
from ukrdc_fastapi.schemas.common import HistoryPoint
from . import datahealth
router = APIRouter(tags=["Admin"])
router.include_router(datahealth.router, prefix="/datahealth")
@router.get(
"/workitems_history",
response_model=list[HistoryPoint],
dependencies=[
Security(
auth.permission(
[
Permissions.READ_WORKITEMS,
Permissions.UNIT_PREFIX + Permissions.UNIT_WILDCARD,
]
)
)
],
)
def full_workitem_history(
since: Optional[datetime.date] = None,
until: Optional[datetime.date] = None,
jtrace: Session = Depends(get_jtrace),
):
"""Retreive basic statistics about recent records"""
return get_full_workitem_history(jtrace, since, until)
@router.get(
def read_current_user(credentials: HTTPBasicCredentials = Security(security)):
return {"username": credentials.username, "password": credentials.password}
from typing import Optional, List
import fastapi
from fastapi import Depends, Security
from forsguiden.dependencies import on_database
from forsguiden.model import *
from forsguiden.db import Db
from forsguiden.security import behorighet
router = fastapi.APIRouter(tags=["Forssträcka"])
# Forssträcka
_redigera = dependencies = [Security(behorighet("redigera:forsstracka"))]
@router.get("/forsstracka")
async def lista_forsstrackor(db: Db = Depends(
on_database)) -> ForsstrackaCollection:
return ForsstrackaCollection(forsstracka=db.lista_forsstracka())
@router.get("/forsstracka/{id}")
async def hamta_forsstracka_med_id(
id: int, db: Db = Depends(on_database)) -> Forsstracka:
forsstracka = db.hamta_forsstracka(id)
if forsstracka is None:
raise fastapi.HTTPException(status_code=404)
return forsstracka
async def logout(token: str = Security(oauth2_scheme)):
with db_session:
db.BlacklistToken(token=token)
def read_current_user(
credentials: HTTPAuthorizationCredentials = Security(security)):
return {
"scheme": credentials.scheme,
"credentials": credentials.credentials
}
async def read_items(token: Optional[str] = Security(oauth2_scheme)):
if token is None:
return {"msg": "Create an account first"}
return {"token": token}
