def delete_server_by_slug(
server: Server = Depends(get_server_by_slug_from_path),
servers_repo: ServersRepository = Depends(
get_repository(ServersRepository)),
) -> None:
servers_repo.delete_server(server=server)
def read_movies_by_year(year: int, db: Session = Depends(get_db)):
return crud.get_movies_by_year(db=db, year=year)
def read_movies_by_title_year(t: str, y: int, db: Session = Depends(get_db)):
return crud.get_movies_by_title_year(db=db, title=t, year=y)
async def keycloak_token(request: Request,
config: YouwolEnvironment = Depends(yw_config)):
context = ContextFactory.get_instance(
request=request, web_socket=WebSocketsStore.userChannel)
token = await config.get_auth_token(context)
return {"access_token": token}
app = FastAPI()
app.add_middleware(AuthenticationMiddleware, backend=AuthBackend())
Token = get_token_model()
User = get_user_model()
@app.on_event("startup")
async def startup():
setup_exception_handlers(app)
@app.get(
"/authed/",
dependencies=[Depends(PermissionsDependency([IsAuthenticated]))],
)
def authed(request: Request):
return {"username": request.scope["user"].username}
@patch(
"fastapi_contrib.auth.models.User.get",
new=AsyncMock(return_value=User(username="******")),
)
@patch(
"fastapi_contrib.auth.models.Token.get",
new=AsyncMock(return_value=Token()),
)
def test_has_auth_permission():
with TestClient(app) as client:
async def read_users_me(
current_user: schemas.User = Depends(get_current_active_user)):
return current_user
async def read_users_me(
user: UserInLogin = Body(..., embed=True),
current_user: User = Depends(get_current_user_authorizer()),
db: AsyncIOMotorClient = Depends(get_database)
):
return current_user
async def user_me(current_user=Depends(get_current_active_user)):
return current_user
async def user_create(
user: UserCreate,
db=Depends(get_db),
current_user=Depends(get_current_active_superuser),
):
return create_user(db, user)
def post_actors(request: schemas.Actor, db: Session = Depends(get_db)):
new_actor = models.Actor(actor_name=request.actor_name)
db.add(new_actor)
db.commit()
db.refresh(new_actor)
return new_actor
def edit_actor(id, request: schemas.Actor, db: Session = Depends(get_db)):
actor = db.query(models.Actor).filter(models.Actor.id == id)
actor.update(request.dict())
print(request)
db.commit()
return "updated"
def getactorbyid(id: int, db: Session = Depends(get_db)):
actors = db.query(models.Actor).filter(models.Actor.id == id).first()
return actors
def getallactors(db: Session = Depends(get_db)):
actors = db.query(models.Actor).all()
return actors
def weather(
loc: Location = Depends(),
units: Optional[str] = "metric",
):
return f"{loc.city}, {loc.state}, {loc.country} in {units}"
async def get_current_active_user(
current_user: schemas.User = Depends(get_current_user)):
if current_user.disabled:
raise EXCEPTIONS['inactive_user']
return current_user
async def user_delete(
user_id: int,
db=Depends(get_db),
current_user=Depends(get_current_active_superuser),
):
return delete_user(db, user_id)
async def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
return create_user_in_db(user, db)
async def get(
request: Request, engine: sa.engine.Connectable = Depends(get_engine)
) -> Response:
histories = db.find_all(engine)
context = {"request": request, "histories": histories}
return templates.TemplateResponse("index.j2", context)
async def read_own_items(
current_user: schemas.User = Depends(get_current_active_user)):
return [{"item_id": "Foo", "owner": current_user.username}]
async def read_user(
current_user: UserPydantic = Depends(deps.get_current_active_user),
) -> Any:
return current_user
def get_signed_in_user(current_user: Optional[User] = Depends(
get_current_user)) -> User:
if current_user is not None:
return current_user
raise HTTPException(status_code=HTTP_403_FORBIDDEN,
detail="Invalid authentication")
def check_offer_rescind_permissions(offer: OfferInDB = Depends(
get_offer_for_cleaning_from_current_user)) -> None:
if offer.status != "pending":
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Can only rescind currently pending offers.")
def get_current_user(current_user: models.User = Depends(get_user_from_token)):
"""
Retrieves the details of the current user (authenticated).
"""
return current_user
async def list_offers_for_cleaning_by_id_from_path(
cleaning: CleaningInDB = Depends(get_cleaning_by_id_from_path),
offers_repo: OffersRepository = Depends(get_repository(OffersRepository)),
) -> List[OfferInDB]:
return await offers_repo.list_offers_for_cleaning(cleaning=cleaning)
async def get_user(user: users.User_Pydantic = Depends(Auth.get_current_user)):
# print(user.profile)
return user
async def get_current_active_user(
current_user: User = Depends(get_current_user)):
if current_user.disabled:
raise HTTPException(status_code=400, detail="Inactive user")
return current_user
def read_movies_by_range_year(ymin: Optional[int],
ymax: Optional[int],
db: Session = Depends(get_db)):
return crud.get_movies_by_range_year(db=db, year_min=ymin, year_max=ymax)
print(e)
_db.close()
app.include_router(user.router,
prefix="/api/v1",
tags=["user"],
dependencies=[],
responses={404: {
"description": "Not found"
}})
app.include_router(server.router,
prefix="/api/v1/server",
tags=["server"],
dependencies=[Depends(middleware.auth)],
responses={404: {
"description": "Not found"
}})
app.include_router(peer.router,
prefix="/api/v1/peer",
tags=["peer"],
dependencies=[Depends(middleware.auth)],
responses={404: {
"description": "Not found"
}})
app.include_router(wg.router,
prefix="/api/v1/wg",
tags=["wg"],
def read_movies_count(db: Session = Depends(get_db)):
return crud.get_movies_count(db=db)
def retrieve_server_by_slug(
server: Server = Depends(get_server_by_slug_from_path),
) -> ServerInResponse:
return ServerInResponse(server=ServerForResponse.from_orm(server))
