async def logout(request: Request):
response = RedirectResponse(url="/login", status_code=HTTP_302_FOUND)
response.delete_cookie("Authorization")
return response
def dist():
return RedirectResponse("/new/")
async def doc_redirect():
return RedirectResponse(url=f"{PREFIX}/docs")
async def logout(request):
request.session.pop('user', None)
return RedirectResponse(url='/')
async def route_logout_and_remove_cookie():
response = RedirectResponse(url="/")
response.delete_cookie(self.api_key_name,
domain=self.app.app_config.domain)
return response
async def authorize(request: Request, db: Session = Depends(get_db)):
token = await oauth.discord.authorize_access_token(request)
try:
if token:
resp = await oauth.discord.get("users/@me", token=token)
else:
resp = await oauth.discord.get("users/@me")
except UnsupportedTokenTypeError:
raise HTTPException(status_code=400, detail="Unsupported Token-Type")
profile = resp.json()
# Get player
player = db.query(Player).filter_by(discord_id=profile["id"]).first()
# If player doesn't exist, create a new one.
if player is None:
# logger.debug("Player object" + str(profile))
player = Player(
discord_id=profile.get("id"),
name=profile.get("username"),
discriminator=profile.get("discriminator"),
icon=profile.get("avatar"),
)
# Get servers that Player uses
if token:
guilds = await oauth.discord.get("users/@me/guilds", token=token)
else:
guilds = await oauth.discord.get("users/@me/guilds")
# Create new servers if doesn't already exist
for guild in guilds.json():
server = db.query(Server).filter_by(discord_id=guild["id"]).first()
if server is None:
server = Server(
name=guild.get("name"),
icon=guild.get("icon"),
discord_id=guild.get("id"),
)
db.add(server)
player.servers.append(server)
db.add(player)
db.commit()
db.refresh(player)
if token:
# Update token
token_obj = db.query(OAuth2Token).filter_by(
player_id=player.id).first()
if token_obj is None:
token_obj = OAuth2Token(
player_id=player.id,
name="discord",
token_type=token.get("token_type"),
access_token=token.get("access_token"),
refresh_token=token.get("refresh_token"),
expires_at=token.get("expires_at"),
)
else:
token_obj.token_type = (token.get("token_type"), )
token_obj.access_token = (token.get("access_token"), )
token_obj.refresh_token = (token.get("refresh_token"), )
token_obj.expires_at = token.get("expires_at")
db.add(token_obj)
db.commit()
db.refresh(player)
request.session["user"] = player.dict()
url = request.session.get("redirect_url")
if url is None:
url = settings.SITE_HOSTNAME
else:
del request.session["redirect_url"]
return RedirectResponse(url=url)
def redirect_docs():
""" Redirects the root end point to the docs """
return RedirectResponse(url=app.docs_url, status_code=301)
profile["picture"] = src.format(profile["id"], profile["avatar"])
else:
profile[
"picture"] = "https://discord.com/assets/6debd47ed13483642cf09e832ed0bc1b.png" # TODO: function
request.session["user"] = profile
collection = AsyncDatabaseHandler.client["rctbot"]["users"]
if not (account := await collection.find_one(
{"discord_id": int(profile["id"])}, {
"_id": 0,
"username": 1,
"account_id": 1,
"super_id": 1
})):
return RedirectResponse(url="/login/hon")
request.session["user"]["hon"] = account
return RedirectResponse(url="/")
@app.route("/auth/hon", methods=["POST"])
async def auth_hon(request: Request):
user = request.session.get("user")
if not user or "hon" in user:
return RedirectResponse(url="/", status_code=status.HTTP_303_SEE_OTHER)
data = await request.form()
loop = asyncio.get_running_loop()
data = await loop.run_in_executor(None, authenticate, data["username"],
data["password"])
date = datetime.now(timezone.utc)
if b"account_id" not in data:
request.session["user"]["auth"] = {
"alert": "danger",
async def logout(request: Request):
request.session.pop("user", None)
return RedirectResponse(url="/", status_code=status.HTTP_303_SEE_OTHER)
async def route_logout(request):
logout(request.session)
return RedirectResponse('/')
async def get_index():
return RedirectResponse(url="https://www.youtube.com/watch?v=dQw4w9WgXcQ")
def logout(request):
del request.session['user_id']
messages.add(request, 'You are now logged out.', classes=['info'])
return RedirectResponse(url='/')
async def well_known():
"""Alias for /void/"""
return RedirectResponse(url="/void/")
async def auth(request: Request):
token = await oauth.google.authorize_access_token(request)
user = await oauth.google.parse_id_token(request, token)
request.session['user'] = dict(user)
return RedirectResponse(url='/')
def main():
return RedirectResponse(url="/docs/")
'entity': entity,
'answers': ANSWERS,
'request': request,
})
@LoginRequired()
async def learned_word(request: Request) -> Response:
word_id = request.path_params.get('word_id')
try:
word = await (Word.objects.filter(repeat__lte=datetime.now()).get(
id=word_id))
except NoMatch:
raise HTTPException(HTTPStatus.NOT_FOUND)
if answer := request.path_params.get('answer'):
if answer in map(lambda x: x.answer, ANSWERS):
await AnswerHistory.objects.create(
answer=answer,
word=word,
)
answers = await (AnswerHistory.objects.filter(
word__id=word.id).all())
repeat = get_next_repeat(answers)
await word.update(repeat=repeat, )
return RedirectResponse(
request.url_for('learn:index'),
status_code=HTTPStatus.MOVED_PERMANENTLY,
)
async def logout(request: Request):
redirect_url = settings.SITE_HOSTNAME
request.session.pop("user", None)
return RedirectResponse(url=redirect_url)
def main():
''' default function to fetch the backend documentation using starlette redirect response'''
return RedirectResponse(url="/docs/")
def redirect_to_homepage(request):
return RedirectResponse("/")
async def post(
self,
request: Request) -> Union[_TemplateResponse, RedirectResponse]:
data = await request.form()
username = data.get("name", "")
password = data.get("password", "")
captcha_response = data.get("h-captcha-response", "")
errors = []
if not username:
errors.append("The field name is mandatory.")
if not password:
errors.append("The field password is mandatory.")
if (CAPTCHA and not captcha_response):
errors.append("The captcha is mandatory.")
if errors:
return self.__auth_response(request, {"errors": errors})
user = Users.get_or_none(username=username)
if not user:
errors.append("Username or password not valid.")
else:
if not verify_password(password, user.password):
errors.append("Username or password not valid.")
if CAPTCHA:
async with AsyncClient() as client:
response = await client.post("https://hcaptcha.com/siteverify",
data={
"response": captcha_response,
"secret": CAPTCHA_SECRET,
"sitekey": CAPTCHA_SITE_KEY
})
if not response.json()["success"]:
errors.append("Captcha not valid.")
if errors:
return self.__auth_response(request, {"errors": errors}, 401)
sessions_count = len(
UsersSessions.select().where(UsersSessions.user_id == user.id))
sessions_count += 1
jwt_token = jwt_encode({
"username": username,
"is_admin": user.is_admin,
"session": sessions_count,
"ip": request.client.host,
"jti": token_hex(8)
})
UsersSessions.create(user_id=user.id, jwt_token=jwt_token)
redirect = RedirectResponse(request.url_for("home"), status_code=303)
redirect.set_cookie("jwt_token", str(jwt_token), samesite="strict")
return redirect
async def delete(request):
id = request.path_params["id"]
await Book.get(id=id).delete()
response = RedirectResponse(url="/", status_code=302)
return response
async def read_root():
return RedirectResponse(url='/docs')
def root() -> Any:
return RedirectResponse("./docs")
async def delete(request: Request, pk: str, model: Model = Depends(get_model)):
await model.filter(pk=pk).delete()
return RedirectResponse(url=request.headers.get("referer"),
status_code=HTTP_303_SEE_OTHER)
def add_trailing_slash():
return RedirectResponse("/new/")
async def bulk_delete(request: Request,
ids: str,
model: Model = Depends(get_model)):
await model.filter(pk__in=ids.split(",")).delete()
return RedirectResponse(url=request.headers.get("referer"),
status_code=HTTP_303_SEE_OTHER)
async def index():
return RedirectResponse(url="/docs")
async def routePage():
response = RedirectResponse(url="/docs")
return response
async def docs_redirect() -> RedirectResponse:
"""Redirect base request to docs."""
response = RedirectResponse(url="/docs")
return response
def favicon(request: Request):
asset_url = request.url_for("static", path="home-solid.svg")
return RedirectResponse(asset_url)
