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))