def access_token():
return AuthJWT.create_access_token(identity='test', fresh=True)
def get_jwt(Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
# Access the identity of the current user with get_jwt_identity
current_user = Authorize.get_jwt_identity()
return {"logged_in_as": current_user}
def partially_protected(Authorize: AuthJWT = Depends()):
Authorize.jwt_optional()
# If no jwt is sent in the request, get_jwt_subject() will return None
current_user = Authorize.get_jwt_subject() or "anonymous"
return {"user": current_user}
def refresh_revoke(Authorize: AuthJWT = Depends()):
Authorize.jwt_refresh_token_required()
jti = Authorize.get_raw_jwt()['jti']
denylist.add(jti)
return {"detail": "Refresh token has been revoke"}
def protected(Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
return {'hello':'world'}
def generate_parent_with_token(parent: Parent,
auth: AuthJWT) -> ParentWithToken:
access_token = auth.create_access_token(subject=parent.email,
expires_time=timedelta(days=365))
parent.password = "******"
return ParentWithToken(parent=PParent.from_orm(parent), token=access_token)
def get_my_profile_picture(Authorize: AuthJWT = Depends(),
db: Session = Depends(get_db)):
Authorize.jwt_required()
user_id = Authorize.get_jwt_subject()
return get_profile_picture(user_id, db)
async def log_user_out(response: Response, Authorize: AuthJWT = Depends()):
Authorize.unset_jwt_cookies(response)
return {"success": True, "detail": "user signed out"}
async def image_upload(
id: int,
data: Request,
Authorize: AuthJWT = Depends(),
db: Session = Depends(get_db),
):
Authorize.jwt_required()
user_id = Authorize.get_jwt_subject()
dbpost = postCRUD.get(db, id)
raw_image = await data.body()
# CHECKS
if not dbpost:
return JSONResponse(content={'details': 'Post not found'},
status_code=404)
if dbpost.owner_id != user_id:
return JSONResponse(content={'details': 'Post is not current user\'s'},
status_code=401)
if dbpost.image:
return JSONResponse(
content={'details': 'Image is already associated with post'},
status_code=400)
try:
# Opening the image & getting the
# metadata from the image
image = Image.open(io.BytesIO(raw_image))
meta = get_metadata(image)
if meta:
# Putting in the time the photo was taken
# if the data is available
if "DateTimeOriginal" in meta:
date_str = meta["DateTimeOriginal"]
print("Taken at: " + date_str)
# dbpost = postCRUD.update(db, db_obj=dbpost, obj_in={
# 'datetime_taken': datetime.strptime(date_str, "%Y:%m:%d %H:%M:%S")})
# Converting the image to a JPG no
# matter the format it was taken in
image = image.convert("RGB")
# Setting variables and getting UUIDs
# for identifying images
cleaned = io.BytesIO()
cleaned_uuid = str(uuid.uuid4())
cleaned_name = cleaned_uuid + ".jpg"
image.save(cleaned, format='JPEG')
# Getting a thumbnail
thumbnail = io.BytesIO()
thumbnail_uuid = str(uuid.uuid4())
thumbnail_name = thumbnail_uuid + ".jpg"
width, height = image.size
image.thumbnail((width, 120) if (width >= height) else (120, height))
image = crop_center(image, 120, 120)
image.save(thumbnail, format='JPEG')
# Uploading the images as blobs to Google Cloud Storage
upload_image_blob("snapquest-post-images", cleaned_name, cleaned)
upload_image_blob("snapquest-post-images", thumbnail_name, thumbnail)
except UnidentifiedImageError:
raise HTTPException(400, "File uploaded was not an image")
# TODO: Put image in google cloud
# TODO: Don't put image into database, and put reference instead
dbimage = postCRUD.file_upload(db,
id=id,
image=cleaned.getvalue(),
thumbnail=thumbnail.getvalue())
return Response(dbimage, media_type='image/jpeg')
def fresh_jwt_required(Authorize: AuthJWT = Depends()):
Authorize.fresh_jwt_required()
return {'hello': 'world'}
def logout(Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
Authorize.unset_jwt_cookies()
response = JSONResponse({"detail": "Successfully logout"})
response.unset_cookie()
return response
def jwt_refresh_required(Authorize: AuthJWT = Depends()):
Authorize.jwt_refresh_token_required()
return {'hello': 'world'}
def jwt_optional(Authorize: AuthJWT = Depends()):
Authorize.jwt_optional()
if Authorize.get_jwt_identity():
return {'hello': 'world'}
return {'hello': 'anonym'}
def refresh_token():
return AuthJWT.create_refresh_token(identity='test')
def all_token(Authorize: AuthJWT = Depends()):
access_token = Authorize.create_access_token(subject=1,fresh=True)
refresh_token = Authorize.create_refresh_token(subject=1)
Authorize.set_access_cookies(access_token)
Authorize.set_refresh_cookies(refresh_token)
return {"msg":"all token"}
def protected(Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
current_user = Authorize.get_jwt_identity()
return {"logged_in_as": current_user}
def unset_all_token(Authorize: AuthJWT = Depends()):
Authorize.unset_jwt_cookies()
return {"msg":"unset all token"}
def refresh_revoke(Authorize: AuthJWT = Depends()):
Authorize.jwt_refresh_token_required()
jti = Authorize.get_raw_jwt()['jti']
redis_conn.setex(jti, REFRESH_EXPIRES, 'true')
return {"msg": "Refresh token revoked"}
def login(user: User):
if user.username != 'test' or user.password != 'test':
raise HTTPException(status_code=401,detail='Bad username or password')
access_token = AuthJWT.create_access_token(identity=user.username)
return access_token
def user(Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
foo_claims = Authorize.get_raw_jwt()['foo']
return {"foo": foo_claims}
def refresh(Authorize: AuthJWT = Depends()):
Authorize.jwt_refresh_token_required()
current_user = Authorize.get_jwt_subject()
new_access_token = Authorize.create_access_token(subject=current_user)
return {"access_token": new_access_token}
def get_identity(Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
return Authorize.get_jwt_identity()
def protected(Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
current_user = Authorize.get_jwt_subject()
return {"user": current_user}
def test_get_jwt_jti(client,default_access_token,encoded_token):
assert AuthJWT.get_jti(encoded_token=encoded_token) == default_access_token['jti']
def test_valid_header(client):
token = AuthJWT.create_access_token(identity='test')
response = client.get('/protected',headers={'Authorization':f"Bearer {token.decode('utf-8')}"})
assert response.status_code == 200
assert response.json() == {'hello':'world'}
def raw_token(Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
return Authorize.get_raw_jwt()
def login(user: User, Authorize: AuthJWT = Depends()):
if user.username != "test" or user.password != "test":
raise HTTPException(status_code=401, detail="Bad username or password")
access_token = Authorize.create_access_token(subject=user.username)
return {"access_token": access_token}
def get_refresh_token(Authorize: AuthJWT = Depends()):
Authorize.jwt_refresh_token_required()
return Authorize.get_jwt_subject()
async def stats(websocket: WebSocket, app_name: str, Authorize: AuthJWT = Depends()):
auth_setting = str(settings.DISABLE_AUTH)
if auth_setting.lower() == "true":
pass
else:
try:
csrf = websocket._cookies["csrf_access_token"]
Authorize.jwt_required("websocket", websocket=websocket, csrf_token=csrf)
except AuthJWTException:
await websocket.close(code=status.WS_1008_POLICY_VIOLATION)
await websocket.accept()
async with aiodocker.Docker() as docker:
cpu_total = 0.0
cpu_system = 0.0
cpu_percent = 0.0
container: DockerContainer = await docker.containers.get(app_name)
if container._container["State"]["Status"] == "running":
stats = container.stats(stream=True)
async for line in stats:
if line["memory_stats"]:
mem_current = line["memory_stats"]["usage"]
mem_total = line["memory_stats"]["limit"]
mem_percent = (mem_current / mem_total) * 100.0
else:
mem_current = None
mem_total = None
mem_percent = None
try:
(
cpu_percent,
cpu_system,
cpu_total,
) = await calculate_cpu_percent2(line, cpu_total, cpu_system)
except KeyError as e:
print("error while getting new CPU stats: %r, falling back")
cpu_percent = await calculate_cpu_percent(line)
full_stats = {
"time": line["read"],
"cpu_percent": cpu_percent,
"mem_current": mem_current,
"mem_total": mem_total,
"mem_percent": mem_percent,
}
try:
await websocket.send_text(json.dumps(full_stats))
except ConnectionClosedOK as e:
await websocket.close(code=e.code)
break
except RuntimeError as e:
if (
e.args[0]
== 'Cannot call "send" once a close message has been sent.'
):
break
else:
print(e)
else:
await websocket.close(code=status.WS_1011_INTERNAL_ERROR)
def jwt_optional(Authorize: AuthJWT = Depends()):
Authorize.jwt_optional()
return {'hello': 'world'}
