def workouts(username):
"""
Show users past and future workouts.
:param username Is references the user to be displayed.
"""
target_user = get_user(username)
workout_to_edit = None
if request.method == 'POST':
update_workout_filter(request)
if 'EditWorkout' in request.form:
workout_to_edit = int(request.form['EditWorkout'])
completed_workouts = Workout.get_by_user(target_user, False)
missing_workouts = Workout.plan_missing(target_user, completed_workouts)
if session['workout_filter'] is not None:
completed_workouts = [w for w in completed_workouts
if EXERCISE_NAMES[w.exercise] == session['workout_filter']]
view_data = views.Workouts(target_user,
username_is_logged_in(target_user.username),
workout_to_edit,
completed_workouts, missing_workouts)
return render_template('workouts.html', workouts=view_data)
def post(self):
workout_title = self.request.get("workout")
new_workout = Workout(parent = PARENT_KEY, title = workout_title)
new_workout.put()
arguments = self.request.arguments()
exercises = [ {} for i in range( utils.findLength(arguments) ) ]
print exercises
for argu in arguments:
if str(argu) != 'workout':
num = utils.findPosition(argu)
if utils.is_time(argu):
exercises[num]['time'] = int(self.request.get(argu))
if utils.is_rest(argu):
exercises[num]['rest'] = int(self.request.get(argu))
if utils.is_name(argu):
exercises[num]['name'] = str(self.request.get(argu))
print exercises
for counter, exercise in enumerate(exercises): ## Needs to be ordered
print counter
print exercise
new_exercise = Exercise(parent = PARENT_KEY,
name = exercise['name'],
time = exercise['time'],
rest = exercise['rest'],
workout_title = workout_title,
order = counter)
new_exercise.put()
self.redirect('/home')
def saveWorkout(request):
rtn_dict = {'success': False, "msg": ""}
if request.method == 'POST':
try:
if not request.user.id:
user_id = request.POST['user']
else:
user_id = request.user.id
account = Account.objects.get(pk=request.POST['account'])
workout = Workout(name=request.POST['name'], account=account)
workout.save()
for exercise_id in request.POST.getlist('exercises[]'):
exercise = Exercise.objects.get(pk=exercise_id)
workout.exercises.add(exercise)
rtn_dict['success'] = True
except Exception as e:
print e
logger.info('Error saving workout {0}'.format(e))
rtn_dict['msg'] = 'Error saving workout {0}'.format(e)
else:
rtn_dict['msg'] = 'Not POST'
return HttpResponse(json.dumps(rtn_dict, cls=DjangoJSONEncoder), content_type="application/json")
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 update_workout(id):
try:
workout = Workout.update({
'end_time': datetime.now()
}).where(Workout.id == id)
workout.execute()
return Workout.get(Workout.id == id)
except Exception as e:
print("HUGE", str(e))
return str(e)
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 create_workouts(social_auth_user, raw_workouts):
created_workouts = []
for provider_id, raw_workout in raw_workouts.iteritems():
workout = Workout(**raw_workout)
workout.save()
created_workouts.append(workout)
logger.info('Created {0} for {1}'.format(workout, social_auth_user.user))
# We want to wait until markers have been checked for each worker before updating
# leaderboards, so use chord to wait for all subtasks to complete.
header = [check_workout_for_markers.s(workout) for workout in created_workouts]
callback = update_leaderboards_for_user.subtask(args=(social_auth_user.user,), immutable=True)
chord(header)(callback)
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 delete_workout(id):
if 'user_id' not in session:
return redirect('/')
workout = Workout.get(id)
user_id = workout.user_id
if session.get('user_id') != user_id:
return redirect('/')
Workout.delete(id)
flash("Workout Deleted")
return redirect(f'/users/{user_id}/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 get_workout(id):
if request.method == 'OPTION':
return Response()
user_id = session.get('user_id', None)
if user_id is None:
return jsonify({'success': False}), 403
workout = Workout.get(id)
if workout.user.id != user_id:
return jsonify({'success': False}), 403
return jsonify(Workout.serialize(id))
def workout_add(request, id):
complex = Complexe.objects.get(pk=id)
data = RequestContext(request, {
'complex': complex,
'posted': False})
if request.method == 'POST':
if not WorkoutDate.objects.filter(date=request.POST['date'],
complex=id):
workout_date = WorkoutDate(date=request.POST['date'],complex_id=id)
workout_date.save()
else:
workout_date = WorkoutDate.objects.get(date=request.POST['date'],complex=id)
for i in request.POST:
if re.match('exercise_[0-9]+_times', i):
exercise_id = re.match('exercise_([0-9]+)_times', i).group(1)
workout = Workout()
workout.load = request.POST['exercise_' + exercise_id + '_load']
workout.times = request.POST['exercise_' + exercise_id + '_times']
workout.repeats = request.POST['exercise_' + exercise_id + '_repeats']
workout.exercise_id = exercise_id
workout.date_id = workout_date.id
workout.save()
exercise = Exercise.objects.get(pk=exercise_id)
exercise.current_load = workout.load
exercise.current_times = workout.times
exercise.current_repeats = workout.repeats
exercise.save()
data['posted'] = True
return render_to_response('complex.html', data)
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 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 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 get(self):
workouts_query = Workout.query(ancestor = PARENT_KEY)
exercise_query = Exercise.query(ancestor = PARENT_KEY).order( Exercise.order )
template = jinja_env.get_template("templates/index.html")
print 'self response'
print self.response
self.response.write(template.render( {"workouts_query": workouts_query, "exercise_query" : exercise_query} ))
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 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 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 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 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 add_workoutday(id):
if 'user_id' not in session:
return redirect('/')
workout = Workout.get(id)
if session.get('user_id') != workout.user_id:
return redirect('/')
form = DayForm()
form.weekday.choices = [(day, day) for day in Workout.available_days(id)]
if form.validate_on_submit():
WorkoutDay.add(id, form.weekday.data)
db.session.commit()
return redirect(f'/workouts/{id}')
return render_template('add_day.html', form=form)
def update_workout(id):
if request.method == 'OPTION':
return Response()
user_id = session.get('user_id', None)
if user_id is None:
return jsonify({'success': False}), 403
workout = Workout.get(id)
if workout.user.id != user_id:
return jsonify({'success': False}), 403
name = request.get_json().get('name')
Workout.update(id, name)
return jsonify({'success': True})
def index():
if 'user_id' in session:
user = User.query.filter(User.id == session.get('user_id')).one()
if user.active_workout is not None:
workout = Workout.get(user.active_workout)
day = find_closest_workout(workout)
return render_template('index.html', day=day)
return render_template('index.html', day=None)
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 get_workouts(id):
user_id = session.get('user_id', None)
if user_id is None:
return redirect('/')
elif user_id != id:
return redirect('/')
workouts = Workout.get_for(user_id)
return render_template('workouts.html', workouts=workouts)
def post_workout(workout_values):
try:
workout = Workout.create(name=workout_values['name'],
creator=workout_values['creator'],
category=workout_values['category'],
exercises=workout_values['exercises'])
LiveWorkouts.create(user=workout_values['creator'], workout=workout)
return model_to_dict(workout)
except Exception as e:
print("ERROR", str(e))
return e
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 new_workout():
session = db.session()
w = Workout.from_api(flask.request.json)
w.user = g.identity
session.add(w)
session.commit()
return flask.jsonify({
"status": "ok"
})
def refresh_workout_dict(user_key_str, new_workout=None):
user_key = ndb.Key(urlsafe=user_key_str)
if user_key:
workouts = map(workout_to_dict, Workout.query(Workout.user_key == user_key).fetch())
else:
workouts = []
if new_workout is not None:
workouts.append(workout_to_dict(new_workout))
session['workouts'] = workouts
return workouts
def refresh_workout_dict(user_key_str, new_workout=None):
user_key = ndb.Key(urlsafe=user_key_str)
if user_key:
workouts = map(workout_to_dict,
Workout.query(Workout.user_key == user_key).fetch())
else:
workouts = []
if new_workout is not None:
workouts.append(workout_to_dict(new_workout))
session['workouts'] = workouts
return workouts
def multi():
session = db.session()
for payload in flask.request.json["workouts"]:
w = Workout.from_api(payload)
w.user = g.identity
session.add(w)
session.commit()
return flask.jsonify({
"status": "ok"
})
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():
if 'user_id' not in session:
return redirect('/')
form = WorkoutForm()
if form.validate_on_submit():
name = form.name.data
workout = workout = Workout.add(name, session['user_id'])
if workout is not None:
flash('Workout created')
return redirect(f'/workouts/{workout.id}')
else:
form.name.errors.append('A workout with this name already exists')
return render_template('add_workout.html', form=form)
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 activate_workout(id):
if request.method == 'OPTIONS':
return Response()
user_id = session.get('user_id', None)
if user_id is None:
return jsonify({'success': False})
workout = Workout.get(id)
if user_id != workout.user_id:
return jsonify({'success': False})
user = User.query.filter(User.id == workout.user_id).one()
user.active_workout = id
db.session.commit()
return jsonify({'success': True})
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 workout(id):
if 'user_id' not in session:
return redirect('/')
workout = Workout.get(id)
if session.get('user_id') != workout.user.id:
return redirect('/')
active = db.session.query(
User.active_workout).filter(User.id == workout.user_id).one()[0]
is_active = False
if workout.id == active:
is_active = True
return render_template('workout.html',
workout=workout,
is_active=is_active)
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 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
