from os import getenv
from base64 import b64decode
from datetime import timedelta
from fastapi import APIRouter, Depends
from api.middlewares import basic_auth
from fastapi.encoders import jsonable_encoder
from dependencies import database, hash_password
from starlette.responses import RedirectResponse
from db.repositories import User as UserRepository
from fastapi.security import OAuth2PasswordRequestForm
from api.security import BasicAuth, Token, create_access_token
from exceptions import UnauthorizedException, ExceptionScheme, RedirectScheme
router = APIRouter()
repo = UserRepository(next(database()))
@router.post("/token",
responses={
200: {
"model": Token
},
401: {
"model": ExceptionScheme
}
})
def receive_token(form_data: OAuth2PasswordRequestForm = Depends()) -> Token:
user = repo.login(form_data.username, hash_password(form_data.password))
if user is None:
raise UnauthorizedException(detail="Incorrect username or password")
from typing import List
from dependencies import database
from api.middlewares import is_admin
from fastapi import APIRouter, Depends
from starlette.responses import JSONResponse
from db.repositories import Answer as AnswerRepository
from db.schemas import Answer, AnswerCreate, AnswerUpdate
from exceptions import BadRequestException, ExceptionScheme
router = APIRouter()
repo = AnswerRepository(next(database()))
@router.post("/",
dependencies=[Depends(is_admin)],
responses={
200: {
"model": Answer
},
403: {
"model": ExceptionScheme
}
})
def create(answer: AnswerCreate) -> Answer:
return repo.create(answer)
@router.get("/{answer_id}",
responses={
200: {
"model": Answer
from db import models
from os import getenv
from jwt import decode
from typing import Optional
from fastapi import Depends
from db.repositories import User
from dependencies import database
from exceptions import ForbiddenException, UnauthorizedException
from api.security import OAuth2PasswordBearerCookie, BasicAuth, TokenData
repo = User(next(database()))
basic_auth = BasicAuth(auto_error=False)
oauth2_scheme = OAuth2PasswordBearerCookie(token_url="/api/v1/auth/token")
async def get_current_user(token: str = Depends(oauth2_scheme)):
credentials_exception = UnauthorizedException(
detail="Could not validate credentials")
payload = decode(token, getenv("SECRET_KEY"), algorithms=["HS256"])
username: Optional[str] = payload.get("sub")
if username is None:
raise credentials_exception
token_data = TokenData(username=username)
user = repo.get_by_username(token_data.username)
if user is None:
raise credentials_exception
return user
from typing import List
from dependencies import database
from api.middlewares import is_admin
from fastapi import APIRouter, Depends
from starlette.responses import JSONResponse
from db.repositories import Question as QuestionRepository
from exceptions import BadRequestException, ExceptionScheme
from db.schemas import Question, QuestionCreate, QuestionUpdate
router = APIRouter()
repo = QuestionRepository(next(database()))
@router.post("/",
dependencies=[Depends(is_admin)],
responses={
200: {
"model": Question
},
401: {
"model": ExceptionScheme
}
})
def create(question: QuestionCreate) -> Question:
return repo.create(question)
@router.get("/{question_id}",
responses={
200: {
"model": Question
def main(firstname: str, lastname: str, username: str, email: str, password: str, is_active: bool, is_super: bool):
user_repo = User(next(database()))
user_schema = UserCreate(firstname=firstname, lastname=lastname, email=email, username=username, password=password,
is_active=is_active, is_super=is_super)
user_repo.create(user_schema)
from typing import List
from dependencies import database
from api.middlewares import is_admin
from fastapi import APIRouter, Depends
from starlette.responses import JSONResponse
from db.repositories import Game as GameRepository
from db.schemas import Game, GameCreate, GameUpdate
from exceptions import BadRequestException, ExceptionScheme
router = APIRouter()
repo = GameRepository(next(database()))
@router.post("/",
dependencies=[Depends(is_admin)],
responses={
200: {
"model": Game
},
401: {
"model": ExceptionScheme
}
})
def create(game: GameCreate) -> Game:
return repo.create(game)
@router.get("/{game_id}",
responses={
200: {