def workout(self, workout_data):
d = datetime.timedelta(hours=workout_data.duration.data.hour,
minutes=workout_data.duration.data.minute)
intense_val = 1
light_val = 0
interval_val = 1
endurance_val = 0
if workout_data.intensity.data == 'light':
intense_val = 0
light_val = 1
if workout_data.workout_type.data == 'endurance':
interval_val = 0
endurance_val = 1
newWorkout = Workout(created=workout_data.date.data,
duration=d,
intense=intense_val,
light=light_val,
interval=interval_val,
endurance=endurance_val,
user_id=session['user_id'])
db_session.add(newWorkout)
db_session.commit()
def post_Workout():
form = NewWorkout()
data = request.form
workout = Workout(author=current_user.username,
name=data["Title"],
E1=data["Excercise1"],
E2=data["Excercise2"],
E3=data["Excercise3"],
E4=data["Excercise5"],
E5=data["Excercise5"],
S1=data["Sets1"],
S2=data["Sets2"],
S3=data["Sets3"],
S4=data["Sets4"],
S5=data["Sets5"],
R1=data["Reps1"],
R2=data["Reps2"],
R3=data["Reps3"],
R4=data["Reps4"],
R5=data["Reps5"])
activity = Activity(name=current_user.username,
type='w',
topic=data["Title"])
db.session.add(workout)
db.session.add(activity)
db.session.commit()
return redirect(url_for("workouts"))
def add_workout():
if request.method == 'POST':
user = User.query.filter_by(name=session['username']).first()
workout = Workout(date=datetime.utcnow(), user_id=user.id)
exercise_count = int(request.form['exercise_count'])
for exercise_num in range(1, exercise_count + 1):
exercise = Exercise(order=1,
exercise_id=request.form['exercise' +
str(exercise_num)],
workout=workout)
weights = request.form.getlist('weight' + str(exercise_num))
reps = request.form.getlist('reps' + str(exercise_num))
set_order = 1
for weight, rep in zip(weights, reps):
work_set = Set(order=set_order,
exercise=exercise,
weight=weight,
reps=reps)
set_order += 1
db.session.add(workout)
db.session.commit()
return redirect(url_for('index'))
exercises = Exercises.query.all()
return render_template('add_workout.html', exercises=exercises)
def add_workout():
body = request.get_json()
if 'age' not in body:
return 'please specify age', 400
if 'user_id' not in body:
return 'please specify user id', 400
if 'height' not in body:
return 'please specify height', 400
if 'weight' not in body:
return 'please specify weight', 400
if 'dedication' not in body:
return 'please specify dedication', 400
if 'goal_id' not in body:
return 'please specify goal id', 400
form = Form(age=body['age'],
user_id=body['user_id'],
height=body['height'],
weight=body['weight'],
dedication=body['dedication'],
goal_id=body['goal_id'])
workout = Workout(age=body['age'],
user_id=body['user_id'],
height=body['height'],
weight=body['weight'],
dedication=body['dedication'],
goal_id=body['goal_id'])
db.session.add(form)
db.session.commit()
return jsonify(form.serialize()), 200
def new_workout():
""" Page for creating a new workout """
if not g.user:
return redirect("/unauthorized")
else:
form = WorkoutForm()
if form.validate_on_submit():
new_workout = Workout(
name = form.name.data,
date = form.date.data,
time = form.time.data,
user_id = g.user.id
)
g.user.workouts.append(new_workout)
db.session.commit()
return redirect(url_for('view_workout',workout_id=new_workout.id))
return render_template("workout/new.html",form=form)
def test_user_workout(self):
"""Does workout get added to user? Then does a set get added to workout?"""
test_workout = Workout(
name = "test",
date = "2021-01-01",
time = 60
)
self.u.workouts.append(test_workout)
db.session.commit()
self.assertEqual(len(self.u.workouts), 1)
test_set = Set(
exercise="test_exercise",
reps = 10,
weight = 150,
workoutid = test_workout.id
)
test_workout.sets.append(test_set)
db.session.commit()
self.assertEqual(len(self.u.workouts.sets), 1)
def generate_workout(time):
wo = Workout()
for e in sample(exercises, len(exercises)):
wo.exercises.append(e)
if wo.get_total_time > time:
wo.exercises.pop()
break
return wo
def upload():
failed = False
# Need 'force=True' for file upload
data = request.get_json(force=True)
# So very, very insecure
username = data.get('username')
password = data.get('password')
user = query_user(username, password)
if user is None:
return redirect(url_for('page_unauthorized'), 'No such user')
action = data.get('action')
user_key = user.key
if action == 'workout':
photo_url, blob_key = get_photo_url_and_blob_key()
try:
workout_dict = data.get('workout')
new_workout = Workout(user_key=user_key,
name=workout_dict.get('name'),
blob_key=blob_key,
photo_url=photo_url,
text=workout_dict.get('text'),
exercises=workout_dict.get('exercises'))
new_workout.put()
except:
print("Failed to create new workout: {0}".format(
sys.exc_info()[0]))
failed = True
elif action == 'stats':
try:
stats_dict = data.get('stats')
new_stats = Stats(
user_key=user_key,
weight=stats_dict.get('weight'),
height_inches=stats_dict.get('height_inches'),
height_feet=stats_dict.get('height_feet'),
body_fat=stats_dict.get('body_fat'),
)
new_stats.put()
except:
print("Failed to create new workout: {0}".format(
sys.exc_info()[0]))
failed = True
else:
return redirect(url_for('page_unauthorized'), 'No such operation')
if failed:
return "failed"
return "success"
def addWorkout():
form = WorkoutForm()
data = request.form()
date = datetime.strptime(data["date], '%m/%d/%y')
dur_min = int(data["duration_minutes"])
dur_sec = int(data["duration_seconds"])
rec = Workout(title=data["title"], user_id=current_identity.id, date, split=data["split"], dur_min, dur_sec, description = data["description"], video=data["video"], audio=data["audio"], photo=data["photo"])
db.session.add(rec)
db.session.commit()
Workouts = Workout.query.all()
return render_template("gym-routine-app/my-workouts.html", workouts=Workouts)
def add_workout(request):
if not request.user.is_authenticated():
return redirect(index)
elif request.method == 'POST':
form = WorkoutForm(request.POST)
name = request.POST['name']
if form.is_valid():
w = Workout(name=name, owner=request.user)
w.save()
return redirect(index)
else:
form = WorkoutForm()
return render(request, 'add_workout.html', {'form': form})
def create_workout(form, user_key=None, photo_url=None, blob_key=None):
try:
new_workout = Workout(user_key=user_key,
name=form.name.data,
blob_key=blob_key,
photo_url=photo_url,
exercises=form.workout_set.data)
new_workout.put()
except:
print("Failed to create new workout: {0}".format(sys.exc_info()[0]))
return None
return new_workout
def _parse_entry(entry):
'''Parse workout data from the entry'''
title = entry.title
sport = _parse_title('[a-zA-Z\s]+', title)
distance = float(_parse_title('[\.|\d]+\skm', title).split(' ')[0])
duration_h = int(_parse_title('\d+\sh', title).split(' ')[0])
duration_m = int(_parse_title('\d+\smin', title).split(' ')[0])
duration_s = int(_parse_title('\d+\ss', title).split(' ')[0])
duration = (duration_h * 3600) + (duration_m * 60) + duration_s
date = mktime(entry.published_parsed)
return Workout(sport=sport,
distance=distance,
duration=duration,
date=date)
def add_workout():
data = request.get_json()
new_workout = Workout(uid=data['user_id'],
rid=data['rid'],
notes=data['notes'],
day=data['day'])
db.session.add(new_workout)
db.session.commit()
return jsonify({
'message': 'Workout added successfully!',
'status': 200,
})
def indexCreate(request):
s = set()
s.add("name")
s.add("age")
s.add("dish")
js2 = list(json.loads(request.body))
for js in js2:
js = dict(js)
s1 = js.keys()
s1 = set(s1)
s2 = s - s1
res = list(Workout.objects.filter(name=js['name']).values())
################## For UPDATING the content and REJECTING if ALREADY FOUND ##########################3
if (len(res) != 0 and len(js) == 3):
js1 = dict(res[0])
js['id'] = js1['id']
if (cmp(js, js1) == 0):
dic = {}
dic['message'] = "Content already Found"
return JsonResponse(dic)
else:
Workout.objects.filter(id=js['id']).update(age=js['age'],
dish=js['dish'])
dic = {}
dic['message'] = "Content updated"
return JsonResponse(dic, status=200)
'''if(js.has_key('name')==False or js.has_key('dish')==False or ja.has_key('age')==False):
dic={}
dic['message']="Contents Missing"
return JsonResponse(dic,status=400)'''
#################### Finding the MISSING PARAMETERS ##############################
if (len(s2) != 0):
dic = {}
ans = ""
for i in s2:
ans += i + " "
dic['message'] = ans + "Missing"
return JsonResponse(dic, status=400)
# All Conditions SATISFIED
ob = Workout(name=js['name'], age=js['age'], dish=js['dish'])
ob.save()
return JsonResponse(successInsert(js2), status=201, safe=False)
def post_workout():
expected_fields = ['name', 'avg_hrt']
if not request.is_json or not all(field in request.get_json()
for field in expected_fields):
return bad_request('Bad or missing data.')
try:
workout = Workout(request.get_json()['name'],
request.get_json()['avg_hrt'])
db.session.add(workout)
db.session.commit()
return jsonify(workout.serialize), 201
except:
return server_error("Unable to create workout")
def generate_workout(category_times, shuffled=True):
wo = Workout()
exc_list = []
for cat, time in category_times:
for i in count():
cat_excercises = grouped_exercises[cat.id]
exc = cat_excercises[i % len(cat_excercises)]
if time > exc.time:
exc_list.append(exc)
time -= exc.time
else:
break
if shuffled:
exc_list = sample(exc_list, len(exc_list))
assoc = set_association(wo, exc_list)
return wo
def create_workout():
try:
all_data = request.get_json()
name = all_data['name']
focus = all_data['focus']
repeat = all_data['repeat']
if 'exercises' in all_data.keys():
exercises = all_data['exercises']
else:
exercises = None
for value in [name, focus, repeat]:
if value is None:
abort(400)
workout = Workout(name=name, focus=focus, repeat=repeat)
except Exception:
abort(400)
if exercises is None:
# insert Workout with no WorkoutExercises rows
try:
workout.insert()
except Exception:
abort(400)
else:
# insert Workout, get id, then create WorkoutExercises rows
try:
workout.insert_without_commit()
for exercise in exercises:
e_id = Exercise.query.filter(
Exercise.name == exercise['name']).first().id
workout_exercise = WorkoutExercise(
workout_id=workout.id,
exercise_id=e_id,
sets=exercise['sets'],
reps=exercise['reps'],
weight=exercise['weight'])
workout_exercise.insert_without_commit()
workout.update()
except Exception:
abort(404)
return jsonify({'success': True, 'id': workout.id})
def setUp(self):
"""
Define test variables and initialize app
Has to be in this awkward camelCase to overload method in TestCase
"""
self.app = create_app()
self.client = self.app.test_client
self.database_path = os.environ['HEROKU_POSTGRESQL_AQUA_URL']
setup_db(self.app, self.database_path)
# binds the app to the current context
with self.app.app_context():
# populate tables with test values
e1 = Exercise(
name='kb swing',
equipment='kettlebell',
target='reps',
link='dummy link'
)
e2 = Exercise(
name='kb goblet squat',
equipment='kettlebell',
target='reps',
link='another dummy link here'
)
e1.insert()
e2.insert()
w = Workout(
name='test workout',
focus='legs',
repeat=False
)
w.insert()
m = WorkoutExercise(
workout_id=1,
exercise_id=1,
sets=3,
reps=8,
weight=4
)
m.insert()
def generate_workout(self, config):
"""
:param config: Config object
:return: A list of WorkoutExercises
"""
wo = Workout()
# Get whitelisted exercises
exc_list = []
whitelisted_exercises = (self.session.query(Exercise).filter(
Exercise.id.in_(config.whitelisted_exercises)).all())
blacklisted_exercises = (self.session.query(Exercise).filter(
Exercise.id.in_(config.blacklisted_exercises)).all())
# Add the whitelisted exercises first
exc_list.extend(whitelisted_exercises)
# Generate exercises per category time allotted excluding whitelisted exercises
for cat_name, time in config.exercise_category_times.items():
exc_for_cat = self.generate_exercises_for_category(
cat_name, time, whitelisted_exercises, blacklisted_exercises)
exc_list.extend(exc_for_cat)
# Shuffle all the categories
exc_list = sample(exc_list, len(exc_list))
self.set_association(wo, exc_list)
return wo
def __init__(self):
if locale.getdefaultlocale()[0] == "en_US":
language = "en"
self.get_en_translation()
else:
language = "es"
self.get_es_translation()
Gtk.Window.__init__(self, title="IPM P1")
self.set_default_size(700, 500)
self.wk_grid = Gtk.Grid()
self.wk_grid.set_column_homogeneous(True)
self.wk_grid.set_row_spacing(20)
self.wk_grid.set_column_spacing(20)
self.scrolled_window = Gtk.ScrolledWindow()
self.scrolled_window.set_border_width(10)
self.add(self.scrolled_window)
self.scrolled_window.add(self.wk_grid)
# get collections from database
self.workouts = define_connection('search_workouts', 'workouts')
self.render_workouts()
self.exercises = define_connection('search_exercises', 'exercises')
self.render_exercises()
self.all_exercises = []
# make objects from all exercises in database
for exercise_db in self.exercises:
try:
exercise = Exercise(exercise_db['_id'],
exercise_db['description'],
exercise_db['image'], exercise_db['name'],
exercise_db['video'])
self.all_exercises.append(exercise)
except:
pass
self.all_workouts = []
# make objects from all workouts in database
exercises_not_in_db = []
for index, workout_db in enumerate(self.workouts):
workout = Workout(workout_db['_id'], workout_db['name'],
workout_db['description'], workout_db['image'])
# attach proper exercises to the workout
exercises_of_workout = []
no = 1
for workout_ex in workout_db['exercises']:
found_exercise_in_db = False
for exercise in self.all_exercises:
if found_exercise_in_db is False and workout_ex[
0] == exercise.name:
id_ = random.randint(1, 10000000)
found_exercise_in_db = True
ex_of_workout = ExerciseToWorkout(
id_, workout.id, exercise.id, workout_ex[1], no)
no = no + 1
exercises_of_workout.append(ex_of_workout)
# if the exercise given with workout is not in the exercises colllection in database
if found_exercise_in_db is False and len(
sys.argv) > 1 and sys.argv[1] == "1":
id_ = random.randint(1, 10000000)
exercise = Exercise(id_, "None", "None", workout_ex[0],
"None")
exercises_not_in_db.append("{}".format(
str(json.dumps(exercise.__dict__))))
self.all_exercises.append(exercise)
ex_of_workout = ExerciseToWorkout(workout.id, exercise.id,
workout_ex[1], no)
no = no + 1
exercises_of_workout.append(ex_of_workout)
# add list of exercises to the routine for faster displaying
workout.set_exercises(exercises_of_workout)
self.all_workouts.append(workout)
if len(sys.argv) > 1 and sys.argv[1] == "1":
result = define_connection("insert_ex",
"{}".format(exercises_not_in_db))
exercises_json = []
for ex in exercises_of_workout:
ex_json = json.dumps(ex.__dict__)
exercises_json.append(ex_json)
define_connection("insert_ex_to_wk", "{}".format(exercises_json))
self.make_workouts_grid()
from flask import Flask, jsonify, render_template, url_for, request
