示例#1
0
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)
示例#2
0
def read_movies_by_year(year: int, db: Session = Depends(get_db)):
    return crud.get_movies_by_year(db=db, year=year)
示例#3
0
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)
示例#4
0
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}
示例#5
0
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:
示例#6
0
async def read_users_me(
        current_user: schemas.User = Depends(get_current_active_user)):
    return current_user
示例#7
0
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
示例#8
0
async def user_me(current_user=Depends(get_current_active_user)):
    return current_user
示例#9
0
async def user_create(
        user: UserCreate,
        db=Depends(get_db),
        current_user=Depends(get_current_active_superuser),
):
    return create_user(db, user)
示例#10
0
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
示例#11
0
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"
示例#12
0
def getactorbyid(id: int, db: Session = Depends(get_db)):
    actors = db.query(models.Actor).filter(models.Actor.id == id).first()
    return actors
示例#13
0
def getallactors(db: Session = Depends(get_db)):
    actors = db.query(models.Actor).all()
    return actors
示例#14
0
def weather(
    loc: Location = Depends(),
    units: Optional[str] = "metric",
):
    return f"{loc.city}, {loc.state}, {loc.country} in {units}"
示例#15
0
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
示例#16
0
async def user_delete(
        user_id: int,
        db=Depends(get_db),
        current_user=Depends(get_current_active_superuser),
):
    return delete_user(db, user_id)
示例#17
0
async def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
    return create_user_in_db(user, db)
示例#18
0
文件: main.py 项目: 106-/futaba2dat
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)
示例#19
0
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")
示例#22
0
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.")
示例#23
0
def get_current_user(current_user: models.User = Depends(get_user_from_token)):
    """
    Retrieves the details of the current user (authenticated).
    """
    return current_user
示例#24
0
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)
示例#25
0
async def get_user(user: users.User_Pydantic = Depends(Auth.get_current_user)):
    # print(user.profile)
    return user
示例#26
0
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
示例#27
0
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)
示例#28
0
文件: main.py 项目: mowdep/wg-manager
        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"],
示例#29
0
def read_movies_count(db: Session = Depends(get_db)):
    return crud.get_movies_count(db=db)
示例#30
0
def retrieve_server_by_slug(
    server: Server = Depends(get_server_by_slug_from_path),
) -> ServerInResponse:
    return ServerInResponse(server=ServerForResponse.from_orm(server))