def insert_youtube_video():
try:
cur = mysql.connection.cursor()
id = request.get_json()['id']
id_collaborator = request.get_json()['id_collaborator']
video_count = request.get_json()['video_count']
video_link = request.get_json()['video_link']
cur.execute(
"INSERT INTO heroku_012605fb848c7a7.youtube_videos (id, id_collaborator, video_count, video_link) VALUES ('"
+ id + "', '" + id_collaborator + "', '" + video_count + "', '" +
video_link + "');")
mysql.connection.commit()
yt_video = {
'id': id,
'id_collaborator': id_collaborator,
'video_count': video_count,
'video_link': video_link
}
post_log('POST /youtube_videos')
return Response(json.dumps({
"youtube_video": yt_video,
"code": 201
}),
mimetype='application/json')
except Exception as e:
return {"Error": "Unable to create this youtube video."}
def find_workout_by_type(workout_type):
try:
print(workout_type)
cur = mysql.connection.cursor()
cur.execute(
"SELECT * FROM heroku_012605fb848c7a7.curated_workout WHERE workout_type = \""
+ str(workout_type) + "\";")
all_workouts = []
rows = cur.fetchall()
for row in rows:
temp_workout = {}
temp_workout['id'] = row[0]
temp_workout['name'] = row[1]
temp_workout['goal'] = row[2]
temp_workout['workout_type'] = row[3]
temp_workout['level'] = row[4]
temp_workout['days_per_week'] = row[5]
temp_workout['time_per_workout'] = row[6]
temp_workout['targeted_gender'] = row[7]
temp_workout['workout_pdf'] = row[8]
all_workouts.append(temp_workout)
post_log('GET /curated_workout/<string:workout_type>')
return Response(json.dumps({
"curated_workout": all_workouts,
"code": 200
}),
mimetype='application/json')
except Exception as e:
return {
"Error": "Unable to retrieve this workout.",
"ErrorMessage": str(e)
}
def get_all_workouts():
try:
cur = mysql.connection.cursor()
cur.execute("SELECT * From heroku_012605fb848c7a7.curated_workout;")
all_workouts = []
rows = cur.fetchall()
for row in rows:
temp_workout = {}
temp_workout['id'] = row[0]
temp_workout['name'] = row[1]
temp_workout['goal'] = row[2]
temp_workout['workout_type'] = row[3]
temp_workout['level'] = row[4]
temp_workout['days_per_week'] = row[5]
temp_workout['time_per_workout'] = row[6]
temp_workout['targeted_gender'] = row[7]
temp_workout['workout_pdf'] = row[8]
temp_workout['image'] = row[9]
all_workouts.append(temp_workout)
post_log('GET /curated_workout/all')
return Response(json.dumps({
"curated_workouts": all_workouts,
"code": 201
}),
mimetype='application/json')
except Exception as e:
return {
"Error": "Unable to retrive all curated workouts.",
"ErrorMessage": str(e)
}
def update_user_info(userID):
try:
cur = mysql.connection.cursor()
first_name = request.get_json()['first_name']
last_name = request.get_json()['last_name']
email = request.get_json()['email']
password = bcrypt.generate_password_hash(
request.get_json()['password']).decode('utf-8')
username = request.get_json()['username']
cur.execute("UPDATE heroku_012605fb848c7a7.users SET first_name = '" +
str(first_name) + "',last_name = '" + str(last_name) +
"',email = '" + str(email) + "',password = '******',username = '******'WHERE id = " + str(userID) + ";")
mysql.connection.commit()
updated = {
'first_name': first_name,
'last_name': last_name,
'email': email,
'password': password,
'username': username
}
post_log('PUT /users/<int:userID>')
return Response(json.dumps({
"updated": updated,
"code": 201
}),
mimetype='application/json')
except Exception as e:
print(e)
return {
"Error": "Unable to update this user.",
"error message": str(e)
}
def find_workout(wkoutID):
try:
cur = mysql.connection.cursor()
cur.execute(
"SELECT * FROM heroku_012605fb848c7a7.curated_workout WHERE id = "
+ str(wkoutID) + ";")
row = cur.fetchone()
workout = {
'id': row[0],
'name': row[1],
'goal': row[2],
'workout_type': row[3],
'level': row[4],
'days_per_week': row[5],
'time_per_week': row[6],
'targeted_gender': row[7],
'workout_pdf': row[8],
}
post_log('GET /curated_workout/<int:wkoutID>')
return Response(json.dumps({
"curated_workout": workout,
"code": 200
}),
mimetype='application/json')
except Exception as e:
return {
"Error": "Unable to retrieve this workout.",
"ErrorMessage": str(e)
}
def get_all_users():
try:
cur = mysql.connection.cursor()
cur.execute("SELECT * FROM heroku_012605fb848c7a7.users;")
all_users = []
rows = cur.fetchall()
for row in rows:
temp_user = {}
temp_user['id'] = row[0]
temp_user['first_name'] = row[1]
temp_user['last_name'] = row[2]
temp_user['email'] = row[3]
temp_user['username'] = row[5]
all_users.append(temp_user)
post_log('GET /users/all')
return Response(json.dumps({
"users": all_users,
"code": 200
}),
mimetype='application/json')
except Exception as e:
return {
"Error": "Unable to retrive all users.",
"error message": str(e)
}
def create_collab():
try:
cur = mysql.connection.cursor()
id = request.get_json()['id']
youtube_link = request.get_json()['youtube_link']
cur.execute("SELECT id FROM heroku_012605fb848c7a7.users Where id = " +
str(id) + ";")
row = cur.fetchone()
foundID = row[0]
#print("row: ", row)
#print("foundID: ", foundID)
#if foundID == None:
# return {"NOT FOUND":"Can't create Collab if given ID does not exist in USER table"}
#else:
cur.execute(
"INSERT INTO heroku_012605fb848c7a7.collaborators (id, youtube_link) VALUES ('"
+ id + "', '" + youtube_link + "');")
mysql.connection.commit()
posted = {'youtube link': youtube_link, 'id': id}
post_log('POST /meals')
return Response(json.dumps({
"posted": posted,
"code": 201
}),
mimetype='application/json')
except Exception as e:
return {
"Error": "Unable to create this collaborator.",
"error message": str(e)
}
def get_all_workouts():
try:
cur = mysql.connection.cursor()
cur.execute("SELECT * From heroku_012605fb848c7a7.workouts;")
all_workouts = []
rows = cur.fetchall()
for row in rows:
temp_workout = {}
temp_workout['id'] = row[0]
temp_workout['workout_name'] = row[1]
temp_workout['main_muscle_group'] = row[2]
temp_workout['detailed_muscle_group'] = row[3]
temp_workout['other_muscle_groups'] = row[4]
temp_workout['type'] = row[5]
temp_workout['mechanics'] = row[6]
temp_workout['equipment'] = row[7]
temp_workout['difficulty'] = row[8]
temp_workout['exercise_steps'] = row[9]
temp_workout['image_path'] = row[10]
all_workouts.append(temp_workout)
post_log('GET /workouts/all')
return Response(json.dumps({"workouts": all_workouts, "code": 201}), mimetype='application/json')
except Exception as e:
return {"Error": "Unable to retrive all workouts.", "ErrorMessage": str(e)}
def find_user(userID):
try:
cur = mysql.connection.cursor()
cur.execute("SELECT * FROM heroku_012605fb848c7a7.users WHERE id = " +
str(userID) + ";")
row = cur.fetchone()
user = {
'first_name': row[1],
'last_name': row[2],
'email': row[3],
'username': row[5],
'id': row[0]
}
post_log('GET /users/<int:userID>')
return Response(json.dumps({
"user": user,
"code": 200
}),
mimetype='application/json')
except Exception as e:
return {
"Error": "Unable to retrieve this user.",
"error message": str(e)
}
def update_youtube_video(videoID):
try:
cur = mysql.connection.cursor()
#id = request.get_json()['id']
id_collaborator = request.get_json()['id_collaborator']
video_count = request.get_json()['video_count']
video_link = request.get_json()['video_link']
cur.execute("UPDATE heroku_012605fb848c7a7.youtube_videos SET id = '" +
str(videoID) + "',id_collaborator = '" +
str(id_collaborator) + "',video_count = '" +
str(video_count) + "',video_link = '" + str(video_link) +
"'WHERE id = " + str(videoID) + ";")
mysql.connection.commit()
yt_video = {
'id': videoID,
'id_collaborator': id_collaborator,
'video_count': video_count,
'video_link': video_link
}
post_log('PUT /youtube_videos/<int:videoID>')
return Response(json.dumps({
"updated": yt_video,
"code": 201
}),
mimetype='application/json')
except Exception as e:
return {"Error": "Unable to update this youtube video."}
def delete_user(userID):
try:
cur = mysql.connection.cursor()
cur.execute("SELECT id FROM heroku_012605fb848c7a7.users Where id = " +
str(userID) + ";")
row = cur.fetchone()
foundID = row[0]
if foundID == None:
return {"NOT FOUND": "User want to delete doesn't exist"}
else:
cur.execute(
"DELETE FROM heroku_012605fb848c7a7.users WHERE id = " +
str(userID) + ";")
mysql.connection.commit()
deleted = {'id': userID}
post_log('DELETE /users/<int:userID>')
return Response(json.dumps({
"deleted": deleted,
"code": 200
}),
mimetype='application/json')
except Exception as e:
return {
"Error": "Unable to delete this user.",
"error message": str(e)
}
def calc_cal():
try:
def user_info():
age = request.get_json()['age']
gender = request.get_json()['gender']
weight = request.get_json()['weight']
height = request.get_json()['height']
if gender == 'male':
c1 = 66
hm = 5 * height
wm = 12.7 * weight
am = 6.7 * age
elif gender == 'female':
c1 = 655
hm = 2 * height
wm = 9.5 * weight
am = 4.7 * age
#BMR = Basal Metabolic Rate Formulas
bmr_result = c1 + hm + wm - am
return(int(bmr_result))
def calculate_activity(bmr_result):
activity_level = request.get_json()['activity']
if activity_level == 'none':
activity_level = 1.2 * bmr_result
elif activity_level == 'light':
activity_level = 1.375 * bmr_result
elif activity_level == 'moderate':
activity_level = 1.55 * bmr_result
elif activity_level == 'high':
activity_level = 1.725 * bmr_result
return(int(activity_level))
def gain_or_lose(activity_level):
goals = request.get_json()['goal']
if goals == 'lose':
calories = activity_level - 500
elif goals == 'maintain':
calories = activity_level
elif goals == 'gain':
calories = activity_level + 500
return int(calories)
cal_count = gain_or_lose(calculate_activity(user_info()))
post_log('GET /calories')
return Response(json.dumps({"Daily calorie to consume": cal_count, "code": 200}), mimetype='application/json')
except Exception as e:
return {"Error": "Unable to calculate calories.", "error message": str(e), "payload sent": request.get_json()}
def login():
try:
cur = mysql.connection.cursor()
username_or_email = request.get_json()['username_or_email']
password = request.get_json()['password']
cur.execute(
"SELECT * FROM heroku_012605fb848c7a7.users where username = %(username)s",
{'username': username_or_email})
rv = cur.fetchone()
cur.execute(
"SELECT * FROM heroku_012605fb848c7a7.users where email = %(email)s",
{'email': username_or_email})
rv_email = cur.fetchone()
result = ''
try:
if bcrypt.check_password_hash(rv[4], password):
access_token = create_access_token(
identity={
'first_name': rv[1],
'last_name': rv[2],
'email': rv[3],
'id': rv[0],
'username': rv[5]
})
result = access_token
else:
raise Exception('Passwords do not match')
except:
try:
if bcrypt.check_password_hash(rv_email[4], password):
access_token = create_access_token(
identity={
'first_name': rv_email[1],
'last_name': rv_email[2],
'email': rv_email[3],
'id': rv_email[0],
'username': rv_email[5]
})
result = access_token
else:
raise Exception('Passwords do not match')
except:
raise Exception('Passwords do not match')
custom_msg = 'POST /users/login for ' + username_or_email
post_log(custom_msg)
return result
except Exception as e:
print(e)
return {"Error": "Incorrect email or password.", "Allow": "no"}
def delete_workout(wkoutID):
try:
cur = mysql.connection.cursor()
cur.execute("DELETE FROM heroku_012605fb848c7a7.workouts WHERE id = " + str(wkoutID) + ";")
mysql.connection.commit()
deleted = {
'id' : wkoutID
}
post_log('DELETE /workouts/<int:wkoutID>')
return Response(json.dumps({"deleted": deleted, "code": 200}), mimetype='application/json')
except Exception as e:
return {"Error": "Unable to delete this workout.", "ErrorMessage": str(e)}
def reset_password():
try:
cur = mysql.connection.cursor()
email = request.get_json()['email']
if '@' not in email:
return {"Error": "Not a valid email"}
password = request.get_json()['password']
confirmed_password = request.get_json()['confirmed_password']
input_reset_key = request.get_json()['reset_key']
cur.execute(
"SELECT password_reset_key FROM heroku_012605fb848c7a7.users WHERE email = %(email)s",
{'email': email})
raw_reset_key_in_DB = str(cur.fetchone())
mod_reset_key_in_DB = raw_reset_key_in_DB
chars_to_delete = "(',)"
for character in chars_to_delete:
mod_reset_key_in_DB = mod_reset_key_in_DB.replace(character, "")
encrypted_password = bcrypt.generate_password_hash(password).decode(
'utf-8')
if (mod_reset_key_in_DB == input_reset_key):
if (password == confirmed_password):
cur.execute(
"UPDATE heroku_012605fb848c7a7.users SET password_reset_key = NULL;"
)
cur.execute(
"UPDATE heroku_012605fb848c7a7.users SET password = '******' WHERE email = %(email)s",
{'email': email})
#cur.execute("UPDATE heroku_012605fb848c7a7.users SET password = '******' WHERE (email = '"+str(email)+"');")
mysql.connection.commit()
post_log('POST /reset-password')
return {"Allow": "yes"}
else:
return {
"Error": "Passwords do not match!",
"Allow": "No",
"Password": password,
"Conf Pass": confirmed_password
}
else:
return {
"Error":
str(mod_reset_key_in_DB) + "/" + str(input_reset_key) + "/" +
str(encrypted_password)
}
except Exception as e:
return {"Error": str(e), "Allow": "no"}
def delete_youtube_video(videoID):
try:
cur = mysql.connection.cursor()
cur.execute(
"DELETE FROM heroku_012605fb848c7a7.youtube_videos WHERE id = " +
str(videoID) + ";")
mysql.connection.commit()
deleted = {'id': videoID}
post_log('DELETE /youtube_videos/<int:videoID>')
return Response(json.dumps({
"deleted": deleted,
"code": 200
}),
mimetype='application/json')
except Exception as e:
return {"Error": "Unable to delete this youtube video."}
def update_workout_info(wkoutID):
try:
cur = mysql.connection.cursor()
name = request.get_json()['name']
goal = request.get_json()['goal']
workout_type = request.get_json()['workout_type']
level = request.get_json()['level']
days_per_week = request.get_json()['days_per_week']
time_per_workout = request.get_json()['time_per_workout']
targeted_gender = request.get_json()['targeted_gender']
workout_pdf = request.get_json()['workout_pdf']
#STOPPED HERE
cur.execute(
"UPDATE heroku_012605fb848c7a7.curated_workout SET name = '" +
str(name) + "',goal = '" + str(goal) + "',workout_type = '" +
str(workout_type) + "',level = '" + str(level) +
"',days_per_week = '" + str(days_per_week) +
"',time_per_workout = '" + str(time_per_workout) +
"',targeted_gender = '" + str(targeted_gender) +
"',workout_pdf = '" + str(workout_pdf) + "'WHERE id = " +
str(wkoutID) + ";")
mysql.connection.commit()
workout = {
'id': wkoutID,
'name': name,
'goal': goal,
'workout_type': workout_type,
'level': level,
'days_per_week': days_per_week,
'time_per_week': time_per_week,
'targeted_gender': targeted_gender,
'workout_pdf': workout_pdf,
}
post_log('PUT /curated_workout/<int:wkoutID>')
return Response(json.dumps({
"updated": workout,
"code": 201
}),
mimetype='application/json')
except Exception as e:
return {
"Error": "Unable to update this workout.",
"ErrorMessage": str(e)
}
def insert_workout():
try:
cur = mysql.connection.cursor()
id = request.get_json()['id']
name = request.get_json()['name']
goal = request.get_json()['goal']
workout_type = request.get_json()['workout_type']
level = request.get_json()['level']
days_per_week = request.get_json()['days_per_week']
time_per_workout = request.get_json()['time_per_workout']
targeted_gender = request.get_json()['targeted_gender']
workout_pdf = request.get_json()['workout_pdf']
image = request.get_json()['image']
cur.execute(
"INSERT INTO heroku_012605fb848c7a7.curated_workout (id, name, goal, workout_type, level, days_per_week, time_per_workout, targeted_gender, workout_pdf, image) VALUES ('"
+ id + "', '" + name + "', '" + goal + "', '" + workout_type +
"', '" + level + "', '" + days_per_week + "', '" +
time_per_workout + "', '" + targeted_gender + "', '" +
workout_pdf + "', '" + image + "');")
mysql.connection.commit()
workout = {
'id': id,
'name': name,
'goal': goal,
'workout_type': workout_type,
'level': level,
'days_per_week': days_per_week,
'time_per_workout': time_per_workout,
'targeted_gender': targeted_gender,
'workout_pdf': workout_pdf,
'image': image
}
post_log('POST /curated_workouts')
return Response(json.dumps({
"curated workout added": workout,
"code": 201
}),
mimetype='application/json')
except Exception as e:
return {
"Error": "Unable to create this workout.",
"ErrorMessage": str(e)
}
def insert_workout():
try:
cur = mysql.connection.cursor()
id = str(request.get_json()['id'])
workout_name = request.get_json()['workout_name']
main_muscle_group = request.get_json()['main_muscle_group']
detailed_muscle_group = request.get_json()['detailed_muscle_group']
other_muscle_groups = request.get_json()['other_muscle_groups']
type_ = request.get_json()['type']
mechanics = request.get_json()['mechanics']
equipment = request.get_json()['equipment']
difficulty = request.get_json()['difficulty']
excercise_steps = request.get_json()['excercise_steps']
image_path = request.get_json()['image_path']
cur.execute("INSERT INTO heroku_012605fb848c7a7.workouts (id, workout_name, main_muscle_group, detailed_muscle_group, other_muscle_groups, type, mechanics, equipment, difficulty, excercise_steps,image_path) VALUES ('"
+ id + "', '"
+ workout_name + "', '"
+ main_muscle_group + "', '"
+ detailed_muscle_group + "', '"
+ other_muscle_groups + "', '"
+ type_ + "', '"
+ mechanics + "', '"
+ equipment + "', '"
+ difficulty + "', '"
+ excercise_steps + "', '"
+ image_path + "');")
mysql.connection.commit()
workout = {
'id': id,
'workout_name': workout_name,
'main_muscle_group': main_muscle_group,
'detailed_muscle_group' : detailed_muscle_group,
'other_muscle_groups': other_muscle_groups,
'type': type_,
'mechanics': mechanics,
'equipment': equipment,
'difficulty': difficulty,
'excercise_steps': excercise_steps,
'image_path': image_path
}
post_log('POST /workouts')
return Response(json.dumps({"workout added": workout, "code": 201}), mimetype='application/json')
except Exception as e:
return {"Error": "Unable to create this workout.", "ErrorMessage":str(e)}
def update_profile():
try:
cur = mysql.connection.cursor()
id = str(request.get_json()['id'])
age = request.get_json()['age']
bio = request.get_json()['bio']
gender = request.get_json()['gender']
nickname = request.get_json()['nickname']
title = request.get_json()['title']
cur.execute(
"INSERT INTO heroku_012605fb848c7a7.profile_data (id, nickname, title, age, bio, gender) VALUES ('"
+ id + "', '" + nickname + "', '" + title + "', '" + age + "', '" +
bio + "', '" + gender + "');")
mysql.connection.commit()
post_log('POST /profile')
return Response(json.dumps({
"profile_updated": "successful",
"code": 201
}),
mimetype='application/json')
except Exception as e:
try:
# we finna update if post fails
cur.execute(
"UPDATE heroku_012605fb848c7a7.profile_data SET id = '" + id +
"',nickname = '" + nickname + "',title = '" + title +
"',age = '" + age + "',bio = '" + bio + "',gender = '" +
gender + "'WHERE id = " + id + ";")
mysql.connection.commit()
return Response(json.dumps({
"profile_updated": "successful but with UPDATE",
"code": 201
}),
mimetype='application/json')
except Exception as e:
return {
"Error":
f"sir we failed not once, but twice. Twas the issue: {e}"
}
return {"Error": f"Unable to create this profile data. {e}"}
def find_collaborator(collabID):
try:
cur = mysql.connection.cursor()
cur.execute(
"SELECT * FROM heroku_012605fb848c7a7.collaborators WHERE id = " +
str(collabID) + ";")
row = cur.fetchone()
collab = {'youtube_link': row[1], 'id': row[0]}
post_log('GET /meals/<int:collabID>')
return Response(json.dumps({
"collaborator": collab,
"code": 200
}),
mimetype='application/json')
except Exception as e:
return {
"Error": "Unable to retrieve this collaborator.",
"error message": str(e)
}
def delete_collab(collabID):
try:
cur = mysql.connection.cursor()
cur.execute(
"DELETE FROM heroku_012605fb848c7a7.collaborators WHERE id = " +
str(collabID) + ";")
mysql.connection.commit()
deleted = {'id': collabID}
post_log('DELETE /meals/<int:collabID>')
return Response(json.dumps({
"deleted": deleted,
"code": 200
}),
mimetype='application/json')
except Exception as e:
return {
"Error": "Unable to delete this collaborator.",
"error message": str(e)
}
def update_collab_info(collabID):
try:
cur = mysql.connection.cursor()
youtube_link = request.get_json()['youtube_link']
cur.execute(
"UPDATE heroku_012605fb848c7a7.collaborators SET youtube_link = '"
+ str(youtube_link) + "'WHERE id = " + str(collabID) + ";")
mysql.connection.commit()
updated = {'youtube_link': youtube_link}
post_log('PUT /meals/<int:collabID>')
return Response(json.dumps({
"updated": updated,
"code": 201
}),
mimetype='application/json')
except Exception as e:
return {
"Error": "Unable to update this collaborator.",
"error message": str(e)
}
def get_all_youtube_videos():
try:
cur = mysql.connection.cursor()
cur.execute("SELECT * From heroku_012605fb848c7a7.youtube_videos;")
all_youtube_videos = []
rows = cur.fetchall()
for row in rows:
temp_workout = {}
temp_workout['id'] = row[0]
temp_workout['id_collaborator'] = row[1]
temp_workout['video_count'] = row[2]
temp_workout['video_link'] = row[3]
all_youtube_videos.append(temp_workout)
post_log('GET /youtube_videos/all')
return Response(json.dumps({
"youtube_videos": all_youtube_videos,
"code": 201
}),
mimetype='application/json')
except Exception as e:
return {"Error": "Unable to retrive all youtube videos."}
def find_Youtube_Videos(videoID):
try:
cur = mysql.connection.cursor()
cur.execute(
"SELECT * FROM heroku_012605fb848c7a7.youtube_videos WHERE id = " +
str(videoID) + ";")
row = cur.fetchone()
yt_video = {
'id': row[0],
'id_collaborator': row[1],
'video_count': row[2],
'video_link': row[3]
}
post_log('GET /youtube_videos/<int:videoID>')
return Response(json.dumps({
"youtube_video": yt_video,
"code": 200
}),
mimetype='application/json')
except Exception as e:
return {"Error": "Unable to retrieve this youtube video."}
def get_all_collabs():
try:
cur = mysql.connection.cursor()
cur.execute("SELECT * FROM heroku_012605fb848c7a7.collaborators;")
all_collabs = []
rows = cur.fetchall()
for row in rows:
temp_collab = {}
temp_collab['id'] = row[0]
temp_collab['youtube_link'] = row[1]
all_collabs.append(temp_collab)
post_log('GET /collabs/all')
return Response(json.dumps({
"collabs": all_collabs,
"code": 200
}),
mimetype='application/json')
except Exception as e:
return {
"Error": "Unable to retrive all collaborators.",
"error message": str(e)
}
def calc_test():
url = "https://gentle-inlet-25364.herokuapp.com/calories/"
payload = {
"age": "37",
"gender": "male",
"weigth": "180",
"height": "76",
"activity": "light",
"goal": "gain",
"gain": "2"
}
r = requests.post(url, json=payload)
print(r)
print(r.text)
if "code" in r.text:
print("POST Passed")
global caloriesPC
mealPC = caloriesPC + 1
return caloriesPC
post_log('Calorie Calc')
else:
print("calories Failed")
def update_workout_info(wkoutID):
try:
cur = mysql.connection.cursor()
workout_name = request.get_json()['workout_name']
main_muscle_group = request.get_json()['main_muscle_group']
detailed_muscle_group = request.get_json()['detailed_muscle_group']
other_muscle_groups = request.get_json()['other_muscle_groups']
type_ = request.get_json()['type']
mechanics = request.get_json()['mechanics']
equipment = request.get_json()['equipment']
difficulty = request.get_json()['difficulty']
excercise_steps = request.get_json()['excercise_steps']
image_path = request.get_json()['image_path']
cur.execute("UPDATE heroku_012605fb848c7a7.workouts SET workout_name = '"+str(workout_name) + "',main_muscle_group = '" + str(main_muscle_group)+ "',detailed_muscle_group = '"+
str(detailed_muscle_group)+"',other_muscle_groups = '"+ str(other_muscle_groups) + "',type = '" + str(type_)+"',mechanics = '" + str(mechanics)+"',equipment = '" + str(equipment)+ "',difficulty = '" + str(difficulty)+ "',excercise_steps = '" + str(excercise_steps)+ "',image_path = '" + str(image_path)+
"'WHERE id = "+ str(wkoutID)+";")
mysql.connection.commit()
workout = {
'id' : wkoutID,
'workout_name': workout_name,
'main_muscle_group': main_muscle_group,
'detailed_muscle_group' : detailed_muscle_group,
'other_muscle_groups': other_muscle_groups,
'type': type_,
'mechanics': mechanics,
'equipment': equipment,
'difficulty': difficulty,
'excercise_steps': excercise_steps,
'image_path': image_path
}
post_log('PUT /workouts/<int:wkoutID>')
return Response(json.dumps({"updated": workout, "code": 201}), mimetype='application/json')
except Exception as e:
return {"Error": "Unable to update this workout.", "ErrorMessage": str(e)}
def find_workout(wkoutID):
try:
cur = mysql.connection.cursor()
cur.execute("SELECT * FROM heroku_012605fb848c7a7.workouts WHERE id = "+str(wkoutID)+";")
row = cur.fetchone()
workout = {
'id' : row[0],
'workout_name':row[1],
'main_muscle_group':row[2],
'detailed_muscle_group' : row[3],
'other_muscle_group': row[4],
'type': row[5],
'mechanics': row[6],
'equipment': row[7],
'difficulty': row[8],
'exercise_steps': row[9],
'image_path': row[10]
}
post_log('GET /workouts/<int:wkoutID>')
return Response(json.dumps({"workout": workout, "code": 200}), mimetype='application/json')
except Exception as e:
return {"Error": "Unable to retrieve this workout.", "ErrorMessage": str(e)}
def find_profile_data(profileID):
try:
cur = mysql.connection.cursor()
cur.execute(
"SELECT * FROM heroku_012605fb848c7a7.profile_data WHERE id = " +
str(profileID) + ";")
row = cur.fetchone()
data = {
'id': row[0],
'nickname': row[1],
'title': row[2],
'age': row[3],
'bio': row[4],
'gender': row[5]
}
post_log('GET /profile/' + str(profileID))
return Response(json.dumps({
"profile_data": data,
"code": 200
}),
mimetype='application/json')
except Exception as e:
return {"Error": "Unable to retrieve this profile data."}
