def create_user():
"""Allows creating a user"""
data = request.get_json() or {}
if (('username' not in data) or ('email' not in data)
or ('name' not in data) or ('organisation' not in data)
or ('password' not in data) or ('admin' not in data)
or ('reviewer' not in data)):
return bad_request(
'must include username, email, name, organisation, password and admin fields'
)
if User.query.filter_by(username=data['username']).first():
return bad_request('please use a different username')
if User.query.filter_by(email=data['email']).first():
return bad_request('please use a different email address')
try:
data['admin'] = bool(strtobool(data['admin']))
except ValueError:
return bad_request('admin is not boolean')
try:
data['reviewer'] = bool(strtobool(data['reviewer']))
except ValueError:
return bad_request('reviewer is not boolean')
user = User()
user.from_json(data, admin=True)
db.session.add(user)
db.session.commit()
response = jsonify(user.to_json(admin=True))
response.status_code = 201
return response
def edit_user(user_id):
"""Changes user details"""
user = User.query.filter_by(id=user_id).first()
if user is not None:
data = request.get_json() or {}
if 'username' in data and data['username'] != user.username \
and User.query.filter_by(username=data['username']).first():
return bad_request('please use a different username')
if 'email' in data and data['email'] != user.email \
and User.query.filter_by(email=data['email']).first():
return bad_request('please use a different email')
user.from_json(data, admin=True)
db.session.commit()
return jsonify(user.to_json(admin=True))
return error_response(404, "user id doesn't exist")
def get_available_sensors():
headers = request.headers or {}
# Check request
if 'Authorization' not in headers:
return bad_request("Missing 'Authorization' header in request")
# Parse auth
try:
login, password = parse_authorization_header(
headers.get('Authorization'))
except Exception as e:
return server_error(
f"Exception occurred during parsing user credentials: {str(e)}")
try:
user = User.query.filter_by(login=login).first()
except Exception as e:
return server_error(
f"Exception occurred during loading user: {str(e)}")
if user and authorize(login, password, user):
sensors = Sensor.query.filter_by(token=user.token).all()
return create_response_from_data_with_code(
[x.serial_number for x in sensors], 200)
else:
return unauthorized(login)
def get_user():
""" Return user info for authorized user """
resp = None
resp_data = {} # response data
headers = request.headers or {}
# Check request
if 'Authorization' not in headers:
return bad_request("Missing 'Authorization' header in request")
# Parse auth
try:
login, password = parse_authorization_header(headers.get('Authorization'))
except Exception as e:
return server_error(f"Exception occurred during parsing user credentials: {str(e)}")
try:
user = User.query.filter_by(login=login).first()
except Exception as e:
return server_error(f"Exception occurred during loading user: {str(e)}")
if not user:
resp = create_response_from_data_with_code({}, 200)
else:
try:
auth = authorize(login, password, user)
except Exception as e:
return server_error(f"Exception occurred authorization: {str(e)}")
if auth:
resp_data = user.to_dict()
resp = create_response_from_data_with_code(resp_data, 200)
return resp
def get_flower_active_recommendations(id):
logging.info("Called getting flower recommendations endpoint ...")
headers = request.headers or {}
alarms = list()
# Check request
if 'Authorization' not in headers:
return bad_request("Missing 'Authorization' header in request")
# Parse auth
try:
login, password = parse_authorization_header(
headers.get('Authorization'))
except Exception as e:
return server_error(
f"Exception occurred during parsing user credentials: {str(e)}")
try:
user = User.query.filter_by(login=login).first()
except Exception as e:
return server_error(
f"Exception occurred during loading user: {str(e)}")
if user and authorize(login, password, user):
return create_response_from_data_with_code(
_get_alarms_for_flower(user, id, 2), 200)
else:
return unauthorized(login)
def get_flower_by_id(id):
""" Return list of user flowers """
logging.info("Called getting flowers endpoint ...")
headers = request.headers or {}
# Check request
if 'Authorization' not in headers:
return bad_request("Missing 'Authorization' header in request")
# Parse auth
try:
login, password = parse_authorization_header(
headers.get('Authorization'))
except Exception as e:
return server_error(
f"Exception occurred during parsing user credentials: {str(e)}")
try:
user = User.query.filter_by(login=login).first()
except Exception as e:
return server_error(
f"Exception occurred during loading user: {str(e)}")
if user and authorize(login, password, user):
flower = user.flowers.filter_by(id=id).first()
resp_data = flower.to_dict() or {}
resp_data['recommendations'] = _get_alarms_for_flower(user, id, 2)
resp_data['warnings'] = _get_alarms_for_flower(user, id, 1)
resp_data['problems'] = _get_alarms_for_flower(user, id, 0)
return create_response_from_data_with_code(resp_data, 200)
else:
return unauthorized(login)
def accept_data(token):
""" Register sensor if it's new sensor and send data to metrics storage """
# Check token
user = User.query.filter_by(token=token).first()
if not user:
return bad_request("Unregistered token")
data = request.get_json() or {}
if 'serial' not in data:
return bad_request("Request must includes 'serial' field")
# Register sensor if not registered
sensor = Sensor.query.filter_by(token=token,
serial_number=data.get('serial')).first()
if not sensor:
sensor = Sensor()
sensor.serial_number = data.get('serial')
sensor.token = token
sensor.user = user.id
# Commit changes to db
db.session.add(sensor)
db.session.commit()
metric = FlowerMetric()
metric.time = datetime.datetime.now()
metric.sensor = sensor.id
logging.info(f"Received metric: {data}")
metric.temperature = float(data.get('temperature', -1.0))
metric.light = 500.0 - float(data.get('light', -1.0))
metric.soilMoisture = 100.0 - float(data.get('soilMoisture', -1.0)) / 10.0
# Commit changes to db
db.session.add(metric)
db.session.commit()
return create_response_from_data_with_code({}, 204)
def org():
# Get request parameters and check if 'name' is presented
data = request.args
if 'name' not in data:
return bad_request('Parameter name must be in request')
org_found = db.session.query(Org).filter(
or_(Org.name_eng == data['name'], Org.name == data['name'])).first()
if org_found:
result = [org_found.as_json()]
return jsonify(result)
else:
return error_response(404, 'Organization not found')
def create_user_or_return_token():
""" Create user and return it's token if user doesn't exists otherwise return user token """
resp_data = {} # response data
headers = request.headers or {}
# Check request
if 'Authorization' not in headers:
return bad_request("Missing 'Authorization' header in request")
# Parse auth
try:
login, password = parse_authorization_header(headers.get('Authorization'))
except Exception as e:
return server_error(f"Exception occurred during parsing user credentials: {str(e)}")
try:
user = User.query.filter_by(login=login).first()
except Exception as e:
return server_error(f"Exception occurred during loading user: {str(e)}")
# Return token if user already exists
if user:
# Check credentials
try:
if authorize(login, password, user):
resp_data['token'] = user.token
resp = create_response_from_data_with_code(resp_data, 200)
else:
return unauthorized(login)
except Exception as e:
return server_error(f"Exception occurred during authorization: {str(e)}")
else:
# Create user
user = User()
user.login = login
user.password_hash = user.generate_password_hash(password)
user.token = user.generate_token()
resp_data['token'] = user.token
# Commit changes to db
db.session.add(user)
db.session.commit()
resp = create_response_from_data_with_code(resp_data, 200)
return resp
def terrorist():
data = request.args
if 'iin' in data:
ter = db.session.query(Terrorist).filter(
Terrorist.iin == data['iin'].strip()).first()
elif 'lname' in data and 'fname' in data:
ter = db.session.query(Terrorist).filter(
Terrorist.lname == data['lname'].strip().upper(),
Terrorist.fname == data['fname'].strip().upper()).first()
else:
return bad_request(
'parameters iin or lname and fname must be in request')
if ter:
response = jsonify([ter.as_json()])
return response
return error_response(404)
def create_flower():
""" Create flower if it doesn't exists """
logging.info("Called creating flower endpoint ...")
headers = request.headers or {}
# Check request
if 'Authorization' not in headers:
return bad_request("Missing 'Authorization' header in request")
# Parse auth
try:
login, password = parse_authorization_header(
headers.get('Authorization'))
except Exception as e:
return server_error(
f"Exception occurred during parsing user credentials: {str(e)}")
try:
user = User.query.filter_by(login=login).first()
except Exception as e:
return server_error(
f"Exception occurred during loading user: {str(e)}")
if user and authorize(login, password, user):
data = request.get_json() or {}
logging.info(data)
if 'name' not in data or 'type' not in data or 'sensor' not in data:
return bad_request(
f"Request must includes name, sensor and type fields. Request: "
f"{data}")
if Flower.query.filter_by(name=data.get('name')).first():
return error_response(
500, f"Flower with name {data.get('name')} already exists for "
f"user {login}")
sensor = Sensor.query.filter_by(
serial_number=data.get('sensor')).first()
if not sensor or sensor.token != user.token:
bad_request("Incorrect sensor serial number")
flower = Flower()
flower.name = data.get('name')
flower.flower_type = data.get('type')
flower.user = user.id
flower.sensor = sensor.id
flower.last_transplantation_year = data.get('last_transplantation_year') or \
datetime.datetime.now().year
# Commit changes to db
db.session.add(flower)
db.session.commit()
for recommendation_class in recommendation_classes():
recom = RecommendationItem()
recom.r_class = recommendation_class.__name__
recom.flower = flower.id
db.session.add(recom)
db.session.commit()
RecommendationBackGroundTask(
recommendation_class.create_from_db(t_id=recom.id,
flower=flower))
resp_data = flower.to_dict()
resp_data['recommendations'] = _get_alarms_for_flower(user, id, 2)
resp_data['warnings'] = _get_alarms_for_flower(user, id, 1)
resp_data['problems'] = _get_alarms_for_flower(user, id, 0)
return create_response_from_data_with_code(resp_data, 201)
else:
return unauthorized(login)
