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}