def get_logged_in_user(new_request):
# get the auth token
auth_token = new_request.headers.get('Authorization')
if auth_token:
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = User.objects(id=resp)[0]
response_object = {
'status': 'success',
'data': {
'user_id': user.id,
'email': user.email,
'registered_on': str(user.registered_on)
}
}
return response_object, 200
response_object = {
'status': 'fail',
'message': resp
}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
def save_new_article(data):
auth_token = data['Authorization']
user = User.query.filter_by(id=User.decode_auth_token(auth_token)).first()
article = Article.query.filter_by(title=data['title']).first()
catergory = Catergory.query.filter_by(id=data['catergory_id']).first()
if user and catergory:
if not article:
new_article = Article(
title=data['title'],
content=data['content'],
catergory=catergory.id,
posted_by=user.id
)
user.articles.append(new_article)
db.session.merge(user)
db.session.commit()
response_object = {
'status': 'success',
'message': 'article has been successfully created.',
}
return response_object
else:
response_object = {
'status': 'fail',
'message': 'article already exists',
}
return response_object, 409
else:
response_object = {
'status': 'fail',
'message': 'user or Catergory does not exists',
}
return response_object, 409
def logout_user(data):
if data:
logger.debug(f"Logout User Data: {data}")
# auth_token = data.split(" ")[1]
auth_token = data
else:
auth_token = ''
if auth_token:
resp = User.decode_auth_token(auth_token)
# If valid, decode_auth_token returns a string
# if not, it returns a dict
if isinstance(resp, str):
# mark the token as blacklisted
return save_token(token=auth_token)
else:
response_object = {
'status': 'fail',
'message': resp['error']
}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 403
def get_logged_in_user(new_request):
# get the auth token
auth_token = new_request.headers.get('authorization')
print('JWT: {}'.format(auth_token), file=sys.stderr)
print(dict(new_request.headers), sys.stderr)
if auth_token:
uname = User.decode_auth_token(auth_token)
print('uname: {}'.format(uname), file=sys.stderr)
if isinstance(uname, str):
user = User.query.filter_by(username=uname).first()
if user != None:
response_object = {
'status': 'success',
'data': {
'username': user.username,
'admin': user.admin,
'name': user.name,
'registered_on': str(user.registered_on)
}
}
return response_object, 200
response_object = {
'status': 'fail',
'message': 'Invalid auth token'
}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
def get_logged_in_user(new_request):
# get the auth token
auth_token = new_request.headers.get('Authorization')
if auth_token:
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = User.query.filter_by(id=resp).first()
admin = False
for _role in user.roles:
if _role.name.value == 'admin':
admin = True
response_object = {
'status': 'success',
'data': {
'user_id': user.id,
'email': user.email,
'admin': admin
}
}
return response_object, 200
response_object = {'status': 'fail', 'message': resp}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
def get_logged_in_user(auth_token):
if auth_token:
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = User.query.filter_by(id=resp).first()
response_object = {
'status': 'success',
'data': {
'user_id': user.id,
'name': user.name,
'username': user.username,
'email': user.email,
'bio': user.bio,
'admin': user.admin,
'registered_on': str(user.registered_on)
}
}
return response_object, 200
response_object = {'status': 'fail', 'message': resp}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token'
}
def validate_admin(request):
# get the auth token
auth_token = request.headers.get('Authorization')
if auth_token:
resp = User.decode_auth_token(auth_token)
payload = jwt.decode(auth_token, key, algorithms='HS256')
if not isinstance(resp, str):
user = User.query.filter_by(id=resp).first()
response_object = {
'status': 'success',
'data': {
'user_id': user.id,
'email': user.email,
'admin': user.admin,
'registered_on': str(user.registered_on)
}
}
return response_object, 200
response_object = {'status': 'fail', 'message': resp}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
def create_diagnosis(token, data, file):
user = User.query.filter_by(
public_id=User.decode_auth_token(token)).first()
try:
data = json.load(data)
except:
response_object = {
'status': 'fail',
'messages': gettext('No json file')
}
return response_object, 400
if data['normal_proba'] + data['murmur_proba'] + data[
'extrasystole_proba'] > 1.0:
response_object = {
'status': 'fail',
'message': gettext('Wrong values of probabilities')
}
return response_object
if data['result'] < 0 or data['result'] > 2:
response_object = {
'status': 'fail',
'message': gettext('Wrong value of result')
}
return response_object, 400
new_diagnosis = Diagnosis(
result=data['result'],
normal_probability=data['normal_proba'],
murmur_probability=data['murmur_proba'],
extrasystole_probability=data['extrasystole_proba'],
public_id=str(uuid.uuid4()),
user_id=user.id)
answer = check_wav_file(file)
if answer['valid']:
write(filename='./app/main/uploads/' +
generate_name(public_id=new_diagnosis.public_id,
checked_on=datetime.utcnow()) + '.wav',
rate=16000,
data=answer['audio'])
else:
return answer['response'], 400
save_diagnosis(new_diagnosis, user)
if not user.subscriber and len(user.diagnoses) > 5:
clear_diagnoses(user)
response_object = {
'status': 'done',
'message': gettext('Diagnosis is saved'),
'diagnosis_id': new_diagnosis.public_id
}
return response_object, 201
def get_logged_in_user(new_request):
# get the auth token
auth_token = new_request.headers.get('Authorization')
if auth_token:
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = User.query.filter_by(id=resp).first()
response_object = {
'status': 'success',
'data': {
'user_id': user.id,
'email': user.email,
'username': user.username,
'joined_at': str(user.joined_at),
}
}
return response_object, 200
response_object = {'status': 'fail', 'message': resp}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
def get_logged_in_user(data):
# get the auth token
auth_token = data
if auth_token:
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = User.query.filter_by(id=resp).first()
response_object = {
'status': 'success',
'data': {
'user_id': user.id,
'email': user.email,
'is_active': user.is_active,
'is_tfa': user.is_tfa,
'is_admin': user.is_admin,
'created_at': str(user.created_at)
}
}
return response_object, 200
response_object = {
'status': 'fail',
'message': resp
}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
def save_satellite(data, auth_header):
id = User.decode_auth_token(auth_header)
address = data['address']
if address:
satellite_name = data['satellite_name']
address = data['address']
is_active = data['is_active']
user_id = id
if user_id:
satellite = Satellite(satellite_name, address, is_active, user_id)
satellite.save()
response = jsonify({
'satellite_name': satellite.satellite_name,
'created_at': satellite.created_at
})
response.status_code = 201
return response
else:
response_object = {
'status': 'fail',
'message': 'satellite save action not success',
}
return response_object, 409
else:
response_object = {
'status': 'fail',
'message': 'Something went wrong',
}
return response_object, 409
def post_new_post(request):
auth_token = request.headers.get('Authorization')
data = request.form
if auth_token:
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = User.query.filter_by(id=resp).first()
image_url = save_image(request.files['image'])
new_post = Post(
public_id=str(uuid.uuid4()),
post_owner=user.username,
image=image_url,
caption=data['caption'],
posted_on=datetime.datetime.utcnow(),
)
save_changes(new_post)
response_object = {
'status': 'success',
'message': 'Success! Post Added to DB.'
}
return response_object, 201
response_object = {'status': 'fail', 'message': resp}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Valid Auth Token Required'
}
return response_object, 401
def get_logged_in_user(new_request):
# get the auth token
auth_token = new_request.headers.get('Authorization').split(" ")[1]
if auth_token:
try:
resp = User.decode_auth_token(auth_token)
user = User.query.filter_by(id=resp['sub']).first()
response_object = {
'status': 'success',
'data': {
'user_id': user.id,
'email': user.email,
'admin': user.is_admin
}
}
return response_object, 200
except TokenException as e:
response_object = {'status': 'fail', 'message': str(e)}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
def delete_user(token):
""" Delete user from database """
user = User.query.filter_by(
public_id=User.decode_auth_token(token)).first()
for diagnosis in user.diagnoses:
filename = './app/main/uploads/' + generate_name(
diagnosis.public_id, diagnosis.checked_on) + '.wav'
os.remove(filename)
db.session.delete(diagnosis)
temp_name = '@' + user.username
db.session.delete(user)
# mark the token as blacklisted
save_token(token=token)
db.session.commit()
response_object = {
'status': 'success',
'message': gettext('User was deleted')
}
return response_object, 200
def get_logged_in_user(new_request):
# get the auth token
auth_header = new_request.headers.get("Authorization")
if auth_header:
auth_token = auth_header.split(" ")[1]
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = User.query.filter_by(id=resp).first()
response_object = {
"status": "success",
"data": {
"user_id": user.id,
"email": user.email,
"admin": user.admin,
"registered_on": str(user.registered_on),
},
}
return response_object, 200
response_object = {"status": "fail", "message": resp}
return response_object, 401
else:
response_object = {
"status": "fail",
"message": "Provide a valid auth token.",
}
return response_object, 401
def save_device(data, auth_header):
id = User.decode_auth_token(auth_header)
mac_address = data['mac_address']
if mac_address:
device_name = data['device_name']
mac_address = data['mac_address']
is_active = data['is_active']
user_id = id
if user_id:
device = Device(device_name, mac_address, is_active, user_id)
device.save()
response = jsonify({
'device_name': device.device_name,
'created_at': device.created_at
})
response.status_code = 201
return response
else:
response_object = {
'status': 'fail',
'message': 'Device save action not success',
}
return response_object, 409
else:
response_object = {
'status': 'fail',
'message': 'Something went wrong',
}
return response_object, 409
def update_device(data, auth_header):
user_id = User.decode_auth_token(auth_header)
id = data['id']
device = Device.query.filter_by(user_id=user_id, id=id).first()
if device:
device.device_name = data['device_name']
device.mac_address = data['mac_address']
device.is_active = data['is_active']
user_id = id
device.save()
response = jsonify({
'status': 'success',
'message': 'Device details update action success',
'device_name': device.device_name,
'mac_address': device.mac_address
})
response.status_code = 201
return response
else:
response_object = {
'status': 'fail',
'message': 'Timer details update action not success',
}
return response_object, 409
def check_login(new_request):
auth_token = new_request.headers.get('Authorization')
if auth_token:
resp = User.decode_auth_token(auth_token)
print(resp)
if not isinstance(resp, str):
user = User.query.filter_by(id=resp).first()
print(user.email)
if user.name is None or (user.type_user == 'fb'
and user.phone_number is None) or (
user.type_user == 'google'
and user.job is None):
response_object = {
'status': 'failse',
'message': 'please provider infomation user'
}
return response_object, 200
response_object = {
'status': 'success',
'data': {
'user_id': user.id,
'email': user.email,
'admin': user.admin,
'registered_on': str(user.registered_on)
}
}
return response_object, 200
response_object = {'status': 'fail', 'message': resp}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
def get_logged_in_user(new_request):
# get the auth token
auth_token = new_request.headers.get('Authorization')
if auth_token:
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
try:
user = User.objects.get({'_id': resp})
except DoesNotExist:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
else:
response_object = {
'status': 'success',
'data': {
'userId': user.userId,
'userName': user.userName,
'email': user.email,
'dateRegistered': str(user.dateRegistered),
'admin': user.admin
}
}
return response_object, 200
response_object = {'status': 'fail', 'message': resp}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
def get_loged_in_user(request):
""" Get the user from the auth token"""
auth_token = request.headers.get('authorization')
if auth_token:
auth_token = auth_token.split(' ')[1]
resp = User.decode_auth_token(auth_token)
if isinstance(resp, int):
user = User.query.filter_by(id=resp).first()
if user:
return {
'status': 'success',
'user_data': {
'user_id': user.id,
'username': user.username,
'is_admin': user.is_admin,
'email': user.email,
'full_time': user.full_time,
'location': user.location,
'keyword': user.keyword
}
}, 200
else:
return {'status': 'fail', 'message': 'user not found'}, 404
else:
return {'status': 'fail', 'message': resp}, 401
return {'status': 'fail', 'message': 'provide valid token'}, 401
def get_logged_in_user(new_request):
# get the auth token
auth_token = new_request.headers.get('Authorization')
auth_token = auth_token.split(" ")[1]
if auth_token:
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = User.query.filter_by(id=resp).first()
response_object = {
'status': 'success',
'data': {
'user_id': user.id,
'admin': user.admin,
'registered_on': str(user.registered_on)
}
}
return response_object, 200
response_object = {'status': 'fail', 'message': resp}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
def update_satellite(data, auth_header):
user_id = User.decode_auth_token(auth_header)
id = data['id']
satellite = Satellite.query.filter_by(user_id=user_id,id=id).first()
if satellite:
satellite.satellite_name = data['satellite_name']
satellite.address = data['address']
satellite.is_active = data['is_active']
satellite.save()
response = jsonify({
'status': 'success',
'message': 'satellite details update action success',
'device_name': satellite.is_active,
'mac_address': satellite.address
})
response.status_code = 201
return response
else:
response_object = {
'status': 'fail',
'message': 'satellite details update action not success',
}
return response_object, 409
def token_to_user(auth_header):
if not auth_header:
return None
token = auth_header.split(" ")[1]
user_id = User.decode_auth_token(token)
user = User.query.get(user_id)
return user
def get_logged_in_user(new_request):
auth_token = new_request.headers.get('Authorization')
if auth_token:
try:
resp = User.decode_auth_token(auth_token.split(" ")[1])
except IndexError as e:
response_object = {
'status':
'fail',
'message':
'some error occurred' if 'Bearer' in list(
auth_token.split(" ")) else 'Bearer does not exist'
}
return response_object, 401
if not isinstance(resp, str):
user = User.query.filter_by(id=resp).first()
response_object = {
'status': 'success',
'data': {
'user_id': user.id,
'email': user.email,
'admin': user.admin,
'registered_on': str(user.registered_on)
}
}
return response_object, 200
response_object = {'status': 'fail', 'message': resp}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 401
def get_logged_in_user(new_request):
# get the auth token
auth_token = new_request.headers.get('Authorization')
if auth_token:
auth_token = auth_token.split(" ")[1]
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = User.query.filter_by(id=resp).first()
response = {
'status': 'success',
'data': {
'user_id': user.id,
'email': user.email,
'admin': user.admin
}
}
return response, 200
else:
response = {'status': 'fail', 'message': resp}
return response, 401
else:
response = {
'status': 'fail',
'message': 'Auth token is not provided.'
}
return response, 401
def logout_user(data):
if data:
try:
auth_token = data.split(" ")[1]
except IndexError:
auth_token = data
else:
auth_token = ''
if auth_token:
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
# mark the token as blacklisted
return save_token(token=auth_token)
else:
response_object = {
'status': 'fail',
'message': resp
}
return response_object, 401
else:
response_object = {
'status': 'fail',
'message': 'Provide a valid auth token.'
}
return response_object, 403
def update_timer(data, auth_header):
user_id = User.decode_auth_token(auth_header)
id = data['id']
timer = Timer.query.filter_by(user_id=user_id,id=id).first()
if timer:
timer.timer_duration = data['timer_duration']
timer.description = data['description']
timer.mac_address = data['mac_address']
timer.is_complete = data['is_complete']
timer.is_cancel = data['is_cancel']
user_id = id
timer.device_id = data['device_id']
timer.save()
response = jsonify({
'status': 'success',
'message': 'Timer details update action success',
'timer_duration': timer.timer_duration,
'mac_address': timer.mac_address,
'created_at': timer.created_at,
'user_id': timer.user_id,
'updated_at': timer.updated_at
})
response.status_code = 201
return response
else:
response_object = {
'status': 'fail',
'message': 'Timer details update action not success',
}
return response_object, 409
def get_logged_in_user(new_request):
""" Get the auth token """
try:
auth_head = new_request.headers.get('Authorization')
except:
auth_head = new_request['Authorization']
else:
auth_head = api.header['Authorization']
auth_token = auth_head.split(' ')[-1]
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = User.query.filter_by(id=resp).first()
response_object = {
'status': 'success',
'data': {
'user_id': user.id,
'email': user.email,
'admin': user.admin,
'registered_on': str(user.registered_on)
}
}
return response_object, 200
else:
response_object = {
'status': 'fail',
'message': resp
# 'message': 'Provide a valid auth token.'
}
return response_object, 401
def test_decode_auth_token(self):
user = User(password='******', registered_on=datetime.datetime.utcnow())
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, bytes))
self.assertTrue(
User.decode_auth_token(auth_token.decode("utf-8")) == 1)
def test_decode_auth_token(self):
user = User(email='*****@*****.**',
password='******',
registered_on=datetime.datetime.utcnow())
db.session.add(user)
db.session.commit()
auth_token = user.encode_auth_token(user.id)
self.assertTrue(isinstance(auth_token, str))
self.assertTrue(User.decode_auth_token(auth_token) == 1)
