async def get_current_user(request: Request,
response: Response,
db_session: Session = Depends(get_db),
Authorize: AuthJWT = Depends()):
try:
Authorize.jwt_required()
except Exception as e:
traceback.print_exc()
raise
token = Authorize.get_raw_jwt()
# admin user
admin = token.get('admin', False)
if admin:
user = get_admin_user_by_email(db_session, token.get('sub'))
if user is None:
raise CREDENTIALS_EXCEPTION
return user
filer = token.get('filer', False)
if filer:
user = get_filer_user_by_email(db_session, token.get('sub'))
if user is None:
raise CREDENTIALS_EXCEPTION
return user
raise CREDENTIALS_EXCEPTION
def postCategory(category: BasePostCategory,
response: Response,
Authorze: AuthJWT = Depends()):
Authorze.jwt_required()
try:
if not get_category(category_name=category.categoryName):
category.created_by = Authorze.get_jwt_subject()
create_category(category)
return {
Statuses.status_code: Statuses.HTTP_200_OK,
Statuses.status: Statuses.success
}
response.status_code = status.HTTP_400_BAD_REQUEST
return {
Statuses.status_code: Statuses.HTTP_BAD_REQUEST,
Statuses.status: Statuses.failed,
Statuses.description: "Category already exists"
}
except Exception as exc:
response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
ProjectUtils.print_log_msg(exc, ProjectUtils.EXCEPTION)
return {
Statuses.status_code: Statuses.HTTP_500_INTERNAL_SERVER_ERROR,
Statuses.status: Statuses.exception,
Statuses.description: str(exc)
}
async def person(
person: Person,
response: Response,
cache: RedisCacheBackend = Depends(redis_cache),
Authorize: AuthJWT = Depends()
) -> Response:
"""
:param cache:
:param response:
:param person:
:type Authorize: object
"""
Authorize.jwt_required()
try:
await cache.set(
"{0}_{1}".format(person.first_name.lower(),
person.last_name.lower()),
json.dumps(person.__dict__))
return Response(status_code=HTTP_201_CREATED,
content=json.dumps(person.__dict__))
except Exception as e:
print(e)
return Response(status_code=HTTP_500_INTERNAL_SERVER_ERROR,
content="Person creation failed")
async def create_agent(data: PyAgentCreateIn, auth: AuthJWT = Depends()):
auth.jwt_required()
subnet = await Subnet.get_or_none(pk=data.subnet_id)
if subnet is None:
raise HTTPException(status_code=400,
detail='Subnet with provided ID does not exist')
try:
agent = await Agent.create(
address=data.address,
subnet=subnet,
token=token_urlsafe(48),
username=data.username,
password=data.password,
)
except IntegrityError as e:
raise HTTPException(status_code=400, detail=str(e))
try:
await deploy(agent)
except Exception as e:
await agent.delete()
raise HTTPException(status_code=500, detail=str(e))
return PyAgent.from_orm(agent)
async def list_agents(auth: AuthJWT = Depends()) -> list[PyAgent]:
auth.jwt_required()
return [
PyAgent.from_orm(agent)
for agent in await Agent.all().prefetch_related('subnet')
]
async def getUser(response: Response, Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
try:
user = Authorize.get_jwt_subject()
obj = get_user_object(username=user)
if obj:
return {
Statuses.status_code:
Statuses.HTTP_200_OK,
Statuses.status:
Statuses.success,
Statuses.data:
SerilizerMixin.serialize(
obj,
unwanted_keys=["password"],
function_keys={"date_of_birth": SerilizerMixin.parseDOb})
}
response.status_code = status.HTTP_400_BAD_REQUEST
return {
Statuses.status_code: Statuses.HTTP_BAD_REQUEST,
Statuses.status: Statuses.failed,
Statuses.description: f"Authentication Failed"
}
except Exception as exc:
response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
ProjectUtils.print_log_msg(exc, ProjectUtils.EXCEPTION)
return {
Statuses.status_code: Statuses.HTTP_500_INTERNAL_SERVER_ERROR,
Statuses.status: Statuses.exception,
Statuses.description: str(exc)
}
async def logs(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:
container: DockerContainer = await docker.containers.get(app_name)
if container._container["State"]["Status"] == "running":
logs = container.log(stdout=True,
stderr=True,
follow=True,
tail=200)
async for line in logs:
try:
await websocket.send_text(line)
except Exception as e:
return e
else:
await websocket.close(code=status.WS_1011_INTERNAL_ERROR)
async def dashboard(websocket: WebSocket, 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)
return
except Exception as exc:
print(exc)
await websocket.close(code=status.WS_1008_POLICY_VIOLATION)
return
await websocket.accept()
tasks = []
async with aiodocker.Docker() as docker:
containers = []
_containers = await docker.containers.list()
for _app in _containers:
if _app._container["State"] == "running":
containers.append(_app)
for app in containers:
_name = app._container["Names"][0][1:]
container: DockerContainer = await docker.containers.get(_name)
stats = container.stats(stream=True)
tasks.append(process_container(_name, stats, websocket))
await asyncio.gather(*tasks)
def get_course(id: int, Authorize: AuthJWT = Depends()):
try:
Authorize.jwt_required()
data = db.get_course_from_id(id)
return request_success(serialize_data(data))
except Exception as e:
return request_error(e)
def inboxq(Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
current_id = Authorize.get_jwt_subject()
all_messages = db.session.query(MessageDB).filter(
MessageDB.recipient_id == current_id).all()
messages = []
test_list = {}
for message in all_messages:
messages.append({
'id': message.id,
'sender_id': message.sender_id,
'body': message.body,
'company_name': message.author.company_name
})
if message.author.company_name in test_list:
test_list[message.author.company_name].append({'id': message.id, 'sender_id': message.sender_id, \
'body': message.body, 'company_name': message.author.company_name})
else:
test_list[message.author.company_name] = [{'id': message.id, 'sender_id': message.sender_id, \
'body': message.body, 'company_name': message.author.company_name}]
print([test_list])
inbox = Inbox(inbox=test_list)
print(inbox)
return inbox
def deleteProduct(product_id: int,
response: Response,
Authorze: AuthJWT = Depends()):
Authorze.jwt_required()
try:
if get_product(product_id=product_id):
delete_product([
product_id,
])
return {
Statuses.status_code: Statuses.HTTP_200_OK,
Statuses.status: Statuses.success
}
response.status_code = status.HTTP_400_BAD_REQUEST
return {
Statuses.status_code: Statuses.HTTP_BAD_REQUEST,
Statuses.status: Statuses.failed,
Statuses.description: f"Product not found {product_id}"
}
except Exception as exc:
response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
ProjectUtils.print_log_msg(exc, ProjectUtils.EXCEPTION)
return {
Statuses.status_code: Statuses.HTTP_500_INTERNAL_SERVER_ERROR,
Statuses.status: Statuses.exception,
Statuses.description: str(exc)
}
def get_parents_baby(id: int,
db: Session = Depends(get_db),
auth: AuthJWT = Depends()):
auth.jwt_required()
baby = db.query(Baby).filter(Baby.parent_ids.contains([id])).one()
validate_baby_relationship(auth, baby.id)
return PBaby.from_orm(baby)
def authentication_required(token: str = Depends(oauth2_scheme),
Authorize: AuthJWT = Depends()):
"""
- Validate user is authenticate
"""
Authorize.jwt_required()
return True
def deleteCategory(category_id: int,
response: Response,
Authorze: AuthJWT = Depends()):
Authorze.jwt_required()
try:
cateObj = get_category(category_id=category_id)
if cateObj:
delete_category([category_id])
return {
Statuses.status_code: Statuses.HTTP_200_OK,
Statuses.status: Statuses.success
}
response.status_code = status.HTTP_400_BAD_REQUEST
return {
Statuses.status_code: Statuses.HTTP_BAD_REQUEST,
Statuses.status: Statuses.failed,
Statuses.description: "Category Not Found"
}
except Exception as exc:
response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
ProjectUtils.print_log_msg(exc, ProjectUtils.EXCEPTION)
return {
Statuses.status_code: Statuses.HTTP_500_INTERNAL_SERVER_ERROR,
Statuses.status: Statuses.exception,
Statuses.description: str(exc)
}
async def person(
first_name: str,
last_name: str,
response: Response,
cache: RedisCacheBackend = Depends(redis_cache),
Authorize: AuthJWT = Depends()
) -> Response:
"""
:param last_name:
:param first_name:
:param user:
:param cache:
:param response:
:type Authorize: object
"""
Authorize.jwt_required()
try:
_persons = await cache.get("{0}_{1}".format(first_name.lower(),
last_name.lower()))
response.status_code = HTTP_200_OK
return Response(content=_persons)
except Exception as e:
return Response(status_code=HTTP_500_INTERNAL_SERVER_ERROR,
content='0')
async def logs(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:
container: DockerContainer = await docker.containers.get(app_name)
if container._container["State"]["Status"] == "running":
logs = container.log(stdout=True, stderr=True, follow=True, tail=200)
async for line in logs:
try:
await websocket.send_text(line)
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)
async def searchUser(response: Response,
email: str = None,
start: int = 0,
limit: int = 10,
Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
try:
if str(email) == str(None):
objs = get_all_user_objects(email)
else:
objs = get_all_user_objects(email)
return {
Statuses.status_code:
Statuses.HTTP_200_OK,
Statuses.status:
Statuses.success,
Statuses.count:
objs.count(),
Statuses.data:
SerilizerMixin.serialize(
objs[start:limit:],
many=True,
unwanted_keys=["password"],
function_keys={"date_of_birth": SerilizerMixin.parseDOb})
}
except Exception as exc:
response.status_code = status.HTTP_500_INTERNAL_SERVER_ERROR
ProjectUtils.print_log_msg(exc, ProjectUtils.EXCEPTION)
return {
Statuses.status_code: Statuses.HTTP_500_INTERNAL_SERVER_ERROR,
Statuses.status: Statuses.exception,
Statuses.description: str(exc)
}
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 Exception as e:
return e
else:
await websocket.close(code=status.WS_1011_INTERNAL_ERROR)
async def addtoCart(product_id: int,
response: Response,
Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
try:
user = Authorize.get_jwt_subject()
obj = get_user_object(username=user)
if obj:
prodObj = get_product(product_id)
if prodObj:
session = SessionLocal()
cart_id = obj.cart(session).cart_id
if session.query(CartProduct).filter(
CartProduct.cart_id == cart_id,
CartProduct.product_id == product_id).count() == 0:
cartProductObj = CartProduct(cart_id=cart_id,
product_id=product_id)
session.add(cartProductObj)
session.commit()
cartProdutsObjs = session.query(CartProduct).filter(
CartProduct.cart_id == cart_id)
session.close()
return {
Statuses.status:
Statuses.success,
Statuses.status_code:
Statuses.HTTP_200_OK,
Statuses.count:
cartProdutsObjs.count(),
Statuses.data:
SerilizerMixin.serialize(cartProdutsObjs, many=True),
Statuses.description:
"Product added succesfully to cart"
}
response.status_code = status.HTTP_400_BAD_REQUEST
return {
Statuses.status_code: Statuses.HTTP_BAD_REQUEST,
Statuses.status: Statuses.failed,
Statuses.description: "Product already in cart"
}
response.status_code = status.HTTP_400_BAD_REQUEST
return {
Statuses.status_code: Statuses.HTTP_BAD_REQUEST,
Statuses.status: Statuses.failed,
Statuses.description: f"product not found --> {product_id}"
}
response.status_code = status.HTTP_400_BAD_REQUEST
return {
Statuses.status_code: Statuses.HTTP_BAD_REQUEST,
Statuses.status: Statuses.failed,
Statuses.description: f"Authentication Failed"
}
except Exception as exc:
ProjectUtils.print_log_msg(exc, ProjectUtils.EXCEPTION)
return {
Statuses.status_code: Statuses.HTTP_500_INTERNAL_SERVER_ERROR,
Statuses.status: Statuses.exception,
Statuses.description: str(exc)
}
def get_current_user(Authorize: AuthJWT = Depends()):
try:
Authorize.jwt_required()
current_user_mail = Authorize.get_jwt_subject()
user_id = db.find_user_by_email(current_user_mail)[0]
return {"current_user": current_user_mail, "id": user_id}
except InvalidHeaderError:
raise HTTPException(409, "Unknown user")
def protected(Authorize: AuthJWT = Depends()):
# Protect an endpoint with jwt_required, which requires a valid access token
# in the request to access.
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 get_parent_from_token(auth: AuthJWT) -> Parent:
session = Session()
try:
email = auth.get_jwt_subject()
auth.jwt_required()
return session.query(Parent).filter_by(email=email).one()
finally:
session.close()
def create_sharing_link(
Authorize: AuthJWT = Depends(),
db: Session = Depends(get_db),
):
Authorize.jwt_required()
user = Authorize.get_jwt_subject()
return {"user": user}
async def list_devices(auth: AuthJWT = Depends()) -> list[PyDevice]:
auth.jwt_required()
return [
PyDevice.from_orm(device)
for device in filter(lambda x: x.subnet is not None, await
Device.all().prefetch_related('subnet'))
]
async def get_device(device_id: int, auth: AuthJWT = Depends()):
auth.jwt_required()
device = await Device.get_or_none(pk=device_id).prefetch_related('subnet')
if device is None or device.subnet is None:
raise HTTPException(status_code=404)
return PyDevice.from_orm(device)
async def user_rate_meal(meal_id: int,
rating: int,
Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
current_user = Authorize.get_jwt_subject()
Rating.insert(user_id=current_user.id, meal_id=meal_id,
rating=rating).execute()
return "ok" # TODO: Better response here.
def inboxf(sender: Sender, Authorize: AuthJWT = Depends()):
Authorize.jwt_required()
current_id = Authorize.get_jwt_subject()
query = db.session.query(MessageDB).filter(
MessageDB.sender_id == sender.sender).filter(
MessageDB.recipient_id == current_id).all()
return query
async def create_subnet(data: PySubnetCreateIn, auth: AuthJWT = Depends()):
auth.jwt_required()
try:
subnet = await Subnet.create(**data.dict())
except IntegrityError as e:
raise HTTPException(status_code=400, detail=str(e))
return PySubnet.from_orm(subnet)
async def get_subnet(subnet_id: int, auth: AuthJWT = Depends()):
auth.jwt_required()
subnet = await Subnet.get_or_none(pk=subnet_id)
if subnet is not None:
return PySubnet.from_orm(subnet)
else:
raise HTTPException(status_code=404)
def logout(Authorize: AuthJWT = Depends()):
"""
Because the JWT are stored in an httponly cookie now, we cannot
log the user out by simply deleting the cookies in the frontend.
We need the backend to send us a response to delete the cookies.
"""
Authorize.jwt_required()
Authorize.unset_jwt_cookies()
return {"msg": "Successfully logout"}
