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 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