def create_bw_entry(self, data):
try:
bw_id = "body_weight" + str(uuid.uuid1())
data.update({"bw_id": bw_id})
for attribute in Body.Body.BODY_WEIGHT_SCHEMA:
if data.get(attribute) is None:
message = "Attribute " + "'" + attribute + "'" + " is not satisfied"
return make_response({"message": message}, 400)
user_id = data.get("user_id")
weight = data.get("weight")
units = data.get("units")
timestamp = data.get("timestamp")
day = data.get("day")
month = data.get("month")
year = data.get("year")
notes = data.get("notes")
self.__body.create_new_body_weight_entry(bw_id, user_id, weight,
units, timestamp, day,
month, year, notes)
return make_response({"bw_id": bw_id}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def delete_entry(self, exercise_entry_id):
try:
self.__exercise.delete_exercise_entry_by_id(exercise_entry_id)
return make_response({}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def delete_bf_entry(self, bf_id):
try:
self.__body.delete_body_fat_entry(bf_id)
return make_response({}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def get_all(self, user_id):
try:
data = self.__body.get_user_body_entries(user_id)
return make_response({"data": data}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def get_types(self, user_id):
try:
data = self.__custom.get_user_custom_types(user_id)
return make_response({"data": data}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def delete_entry(self, custom_entry_id):
try:
self.__custom.delete_custom_entry(custom_entry_id)
return make_response({}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def get_entries_by_year(self, user_id, year):
try:
data = self.__exercise.get_user_exercise_entries_by_year(
user_id, year)
return make_response({"data": data}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def get_bf_entry(self, bf_id):
try:
data = self.__body.get_body_fat_entry_by_id(bf_id)
if data is None:
return make_response({}, 204)
return make_response(data, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def delete(self, user_id):
try:
self.__user.delete_user(user_id)
self.__db.close_connection()
return make_response({}, 200)
except Exception:
self.__db.close_connection()
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def get_entry(self, user_id, day, month, year):
try:
data = self.__diet.get_user_diet_entry(user_id, day, month, year)
if data is None:
return make_response({}, 204)
return make_response(data, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def get(self, user_id):
try:
data = self.__user.get_user_info(user_id)
# if data is None, return 204 (no content)
if data is None:
return make_response({}, 204)
return make_response(data, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def delete_entry(self, user_id, day, month, year):
try:
day = int(day)
month = int(month)
year = int(year)
self.__diet.delete_diet_entry(user_id, day, month, year)
return make_response({}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def encode_token(self, user_id):
try:
payload = {
'exp':
datetime.datetime.utcnow() + datetime.timedelta(days=10),
'iat': datetime.datetime.utcnow(),
'sub': user_id
}
return jwt.encode(payload, self.__secret_key, algorithm="HS256")
except Exception:
error_logger.log_error()
return None
def update(self, data):
try:
user_id = data.get("user_id")
if user_id is None:
return make_response(
{"message": "Attribute 'user_id' is not satisfied"}, 400)
self.__user.update_user_info(user_id, data)
return make_response({}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def update_type(self, data):
try:
custom_id = data.get("custom_id")
if custom_id is None:
return make_response({"message": "Attributes not satisfied"},
400)
self.__custom.update_custom_type(custom_id, data)
return make_response({}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def update_entry(self, data):
try:
user_id = data.get("user_id")
day = int(data.get("day"))
month = int(data.get("month"))
year = int(data.get("year"))
if user_id is None or day is None or month is None or year is None:
return make_response({"message": "Attributes not satisfied"},
400)
self.__diet.update_diet_entry(user_id, day, month, year, data)
return make_response({}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def create_type(self, data):
try:
custom_id = "custom" + str(uuid.uuid1())
user_id = data.get("user_id")
custom_schema = data.get("custom_schema")
if custom_id is None or user_id is None or custom_schema is None:
return make_response({"message": "Attributes not satisfied"},
400)
self.__custom.create_new_custom_type(custom_id, user_id,
custom_schema)
return make_response({"custom_id": custom_id}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def create(self, data):
try:
user_id = data.get("user_id")
email = data.get("email")
name = data.get("name")
# if insufficient data was provided to create a user, return 400 (bad request)
if user_id is None or email is None or name is None:
return make_response(
{"message": "Insufficient data for User object"}, 400)
self.__user.create_new_user(user_id, email, name)
return make_response({}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def update_entry(self, data):
try:
for key in data.keys():
if key not in self.__exercise.EXERCISE_ENTRY_SCHEMA:
message = "Attribute " + "'" + key + "'" + " is not satisfied"
return make_response({"message": message}, 400)
exercise_entry_id = data.get("exercise_entry_id")
if exercise_entry_id is None:
message = "Attribute 'exercise_entry_id' is not satisfied"
return make_response({"message": message}, 400)
self.__exercise.update_exercise_entry(exercise_entry_id, data)
return make_response({}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def update_bf_entry(self, data):
try:
bf_id = data.get("bf_id")
data.update({"bf_id": bf_id})
for key in data.keys():
if key not in Body.Body.BODY_FAT_SCHEMA:
message = "Attribute " + "'" + key + "'" + " is not satisfied"
return make_response({"message": message}, 400)
if bf_id is None:
return make_response(
{"message": "Attribute 'bf_id' is not satisfied"}, 400)
self.__body.update_body_fat_entry(bf_id, data)
return make_response({}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def create_entry(self, data):
try:
custom_entry_id = "custom_entry" + str(uuid.uuid1())
custom_id = data.get("custom_id")
user_id = data.get("user_id")
custom_entry = data.get("custom_entry")
timestamp = data.get("timestamp")
day = data.get("day")
month = data.get("month")
year = data.get("year")
notes = data.get("notes")
if custom_entry_id is None or custom_id is None or user_id is None or custom_entry is None \
or timestamp is None or day is None or month is None or year is None or notes is None:
return make_response({"message": "Attributes not satisfied"},
400)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def create_entries(self, data):
try:
entries = []
created_ids = []
for entry in data:
fields = []
exercise_entry_id = "exercise_entry" + str(uuid.uuid1())
entry.update({"exercise_entry_id": exercise_entry_id})
for attribute in self.__exercise.EXERCISE_ENTRY_SCHEMA:
value = entry.get(attribute)
if value is None:
message = "Attribute " + "'" + attribute + "'" + " is not satisfied"
return make_response({"message": message}, 400)
fields.append(value)
entries.append(fields)
created_ids.append(exercise_entry_id)
self.__exercise.create_new_exercise_entries(entries)
return make_response({"data": created_ids}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
def create_entry(self, data):
try:
user_id = data.get("user_id")
day = int(data.get("day"))
month = int(data.get("month"))
year = int(data.get("year"))
calories = data.get("calories")
protein = data.get("protein")
carbs = data.get("carbs")
fat = data.get("fat")
notes = data.get("notes")
if user_id is None or day is None or month is None or year is None or calories is None or protein is None \
or carbs is None or fat is None or notes is None:
return make_response({"message": "Attributes not satisfied"},
400)
self.__diet.create_new_diet_entry(user_id, day, month, year,
calories, protein, carbs, fat,
notes)
return make_response({}, 200)
except Exception:
error_logger.log_error()
return make_response({}, 500)
finally:
self.__db.close_connection()
