def read_current_user(
credentials: Optional[HTTPAuthorizationCredentials] = Security(security),
):
if credentials is None:
return {"msg": "Create an account first"}
return {"scheme": credentials.scheme, "credentials": credentials.credentials}
async def get_secure_custom_user(user: CustomAuth0User = Security(
auth_custom.get_user)):
return user
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
async def get_active_user_through_cookies(
active_user: UserAuth = Security(get_current_user)):
return active_user
async def get_also_secure(user: Auth0User = Security(auth.get_user)):
return user
async def fetch_users(_=Security(get_current_user, scopes=["admin"])):
"""
Retrieves the list of all users and their information
"""
return await crud.fetch_all(users)
def get_current_user(oauth_header: str = Security(api_key)):
user = User(username=oauth_header)
return user
def get_current_active_superuser(current_user: User = Security(get_current_user)):
if not crud.user.is_superuser(current_user):
raise HTTPException(
status_code=400, detail="The user doesn't have enough privileges"
)
return current_user
async def delete_media(media_id: int = Path(..., gt=0), _=Security(get_current_access, scopes=["admin"])):
"""
Based on a media_id, deletes the specified media
"""
return await crud.delete_entry(media, media_id)
async def read_users(users: List[User] = Security(get_users,
scopes=["users"])):
return users
from pony.orm import db_session
from fastapi.responses import FileResponse, RedirectResponse
from app.developers.security import get_current_dev
from app.utils.jinja2_utils import developer_templates, db_templates
from app.utils.html_utils import Alert
from app.pydantic_models.gen import output_ent as out_pd
from app.pydantic_models.standart_methhods_redefinition import AccessType, AccessMode
from app.db import models as m
dev = APIRouter(
prefix="/dev",
tags=["developer"],
dependencies=[
# Depends(open_db_session),
Security(get_current_dev, scopes=[str(AccessType.DEVELOPER)])
], #
responses={404: {"description": "Not found"}},
)
@dev.get("/me")
@db_session
def personal_page(request: Request, me=Security(get_current_dev, scopes=[str(AccessType.DEVELOPER)])):
me.scopes += [str(AccessType.SELF)]
return developer_templates.TemplateResponse("personal_page.html", {
"request": request,
"alert": Alert("Вы вошли в личный кабинет!", Alert.SUCCESS),
"personal_data": db_templates.get_cooked_template(
"Developer_form.html", {"request": request,
"developer": out_pd.Developer(**dict(me)),
def get_user(current_user: User = Security(get_current_user)):
"""Проверка активный юзер или нет"""
if not crud.user.is_active(current_user):
raise HTTPException(status_code=400, detail="Inactive user")
return current_user
async def get_users(*, token: str = Security(is_auth)): return user.get_users()
async def is_auth(token: str = Security(oauth2_scheme)): return auth.validate(token)
async def get_my_user(me: UserRead = Security(get_current_user,
scopes=["admin", "me"])):
"""
Retrieves information about the current user
"""
return me
def get_current_user(oauth_header: "str" = Security(reusable_oauth2)):
user = User(username=oauth_header)
return user
async def get_user(user_id: int = Path(..., gt=0),
_=Security(get_current_user, scopes=["admin"])):
"""
Based on a user_id, retrieves information about the specified user
"""
return await crud.get_entry(users, user_id)
def read_current_user(
credentials: HTTPAuthorizationCredentials = Security(security)):
return {
"scheme": credentials.scheme,
"credentials": credentials.credentials
}
from app.schemas.farm import Farm
from app.schemas.farm_token import FarmTokenCreate, FarmAuthorizationParams
from app.api.utils.farms import get_farm_by_id, get_oauth_token, get_farm_client, admin_alert_email
from app.api.utils.security import get_farm_access, get_farm_access_allow_public
from app.utils import (generate_farm_registration_link,
send_farm_registration_email,
generate_farm_authorization_link,
send_farm_authorization_email)
logger = logging.getLogger(__name__)
router = APIRouter()
@router.post("/ping-farms/",
dependencies=[Security(get_farm_access)],
response_model=Msg,
status_code=200)
def ping_farms(db: Session = Depends(get_db)):
"""
Ping all active farms.
"""
farm_list = crud.farm.get_multi(db, active=True)
total_response = 0
for farm in farm_list:
try:
farm_client = get_farm_client(db_session=db, farm=farm)
info = farm_client.info()
total_response += 1
except Exception as e:
tags=["farms"],
)
# Include /farms/info endpoint.
api_router.include_router(
info.router,
prefix="/farms/info",
tags=["farm info"],
)
# Include /farms/logs endpoints.
api_router.include_router(logs.router,
prefix="/farms/logs",
tags=["farm logs"],
dependencies=[
Security(get_farm_access,
scopes=['farm:read', 'farm.logs'])
])
# Include /farms/assets endpoints.
api_router.include_router(assets.router,
prefix="/farms/assets",
tags=["farm assets"],
dependencies=[
Security(get_farm_access,
scopes=['farm:read', 'farm.assets'])
])
# Include /farms/terms endpoints.
api_router.include_router(terms.router,
prefix="/farms/terms",
tags=["farm terms"],
def read_current_user(credentials: Optional[HTTPBasicCredentials] = Security(security)):
if credentials is None:
return {"msg": "Create an account first"}
return {"username": credentials.username, "password": credentials.password}
from fastapi import APIRouter
from fastapi import Security
from app.api.api_v1.endpoints import config
from app.api.api_v1.endpoints import domains
from app.api.api_v1.endpoints import login
from app.api.api_v1.endpoints import modules
from app.api.api_v1.endpoints import users
from app.api.api_v1.endpoints import vps
from app.api.utils.security import get_current_user
api_router = APIRouter()
api_router.include_router(login.router, tags=['login'])
api_router.include_router(config.router,
prefix='/config',
tags=['config'],
dependencies=[Security(get_current_user)])
api_router.include_router(users.router, prefix='/users', tags=['users'])
api_router.include_router(vps.router,
prefix='/vps',
tags=['vps'],
dependencies=[Security(get_current_user)])
api_router.include_router(domains.router,
prefix='/domains',
tags=['domains'],
dependencies=[Security(get_current_user)])
api_router.include_router(modules.router,
prefix='/modules',
tags=['modules'],
dependencies=[Security(get_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 get_current_active_user(
current_user: User = Security(get_current_user)
):
if not crud_user.is_active(current_user):
raise HTTPException(status_code=400, detail="Usuario inativo")
return current_user
async def get_secure_scoped(user: Auth0User = Security(
auth.get_user, scopes=[auth0_test_permission])):
return user
async def read_items(token: Optional[str] = Security(oauth2_scheme)):
return {"token": token}
async def read_own_items(
current_user: User = Security(get_current_active_user, scopes=["items"])
):
return [{"item_id": "Foo", "owner": current_user.username}]
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=["Vattendrag"])
# Vattendrag
_redigera = dependencies = [Security(behorighet("redigera:vattendrag"))]
@router.get("/vattendrag")
async def lista_vattendrag(db: Db = Depends(
on_database)) -> VattendragCollection:
return VattendragCollection(vattendrag=db.lista_vattendrag())
@router.get("/vattendrag/{id}")
async def hamta_vattendrag_med_id(
id: int, db: Db = Depends(on_database)) -> Vattendrag:
vattendrag = db.hamta_vattendrag(id)
if vattendrag is None:
raise fastapi.HTTPException(status_code=404)
return vattendrag
def get_current_active_user(current_user: User = Security(get_current_user)):
if not service.user.is_active(current_user):
raise HTTPException(status_code=400, detail="Inactive user")
return current_user
def get_current_active_user(
current_user: UserSecurity = Security(get_current_user)):
if not current_user.isActive:
raise HTTPException(status_code=400, detail="Inactive user")
return current_user
