def view(request, pk): ''' Show the workout schedule ''' template_data = {} schedule = get_object_or_404(Schedule, pk=pk) user = schedule.user is_owner = request.user == user if not is_owner and not user.userprofile.ro_access: return HttpResponseForbidden() uid, token = make_token(user) template_data['schedule'] = schedule if schedule.is_active: template_data[ 'active_workout'] = schedule.get_current_scheduled_workout() else: template_data['active_workout'] = False schedule.get_current_scheduled_workout() template_data['uid'] = uid template_data['token'] = token template_data['is_owner'] = is_owner template_data['owner_user'] = user template_data['show_shariff'] = is_owner return ua_aware_render(request, 'schedule/view.html', template_data)
def calendar(request, username=None, year=None, month=None): ''' Show a calendar with all the workout logs ''' context = {} is_owner, user = check_access(request.user, username) year = int(year) if year else datetime.date.today().year month = int(month) if month else datetime.date.today().month (current_workout, schedule) = Schedule.objects.get_current_workout(user) grouped_log_entries = group_log_entries(user, year, month) context['calendar'] = WorkoutCalendar(grouped_log_entries).formatmonth( year, month) context['logs'] = grouped_log_entries context['current_year'] = year context['current_month'] = month context['current_workout'] = current_workout context['owner_user'] = user context['is_owner'] = is_owner context['impressions'] = WorkoutSession.IMPRESSION context['month_list'] = WorkoutLog.objects.filter(user=user).dates( 'date', 'month') context['show_shariff'] = is_owner and user.userprofile.ro_access return ua_aware_render(request, 'calendar/month.html', context)
def overview(request, username=None): ''' Shows a plot with the weight data More info about the D3 library can be found here: * https://github.com/mbostock/d3 * http://d3js.org/ ''' is_owner, user = check_access(request.user, username) template_data = {} min_date = WeightEntry.objects.filter(user=user).\ aggregate(Min('date'))['date__min'] max_date = WeightEntry.objects.filter(user=user).\ aggregate(Max('date'))['date__max'] if min_date: template_data['min_date'] = 'new Date(%(year)s, %(month)s, %(day)s)' % \ {'year': min_date.year, 'month': min_date.month, 'day': min_date.day} if max_date: template_data['max_date'] = 'new Date(%(year)s, %(month)s, %(day)s)' % \ {'year': max_date.year, 'month': max_date.month, 'day': max_date.day} last_weight_entries = helpers.get_last_entries(user) template_data['is_owner'] = is_owner template_data['owner_user'] = user template_data['show_shariff'] = is_owner template_data['last_five_weight_entries_details'] = last_weight_entries return ua_aware_render(request, 'overview.html', template_data)
def view(request, id, slug=None): ''' Detail view for an exercise ''' template_data = {} template_data['comment_edit'] = False template_data['show_shariff'] = True exercise = get_object_or_404(Exercise, pk=id) template_data['exercise'] = exercise # Create the backgrounds that show what muscles the exercise works on backgrounds = cache.get(cache_mapper.get_exercise_muscle_bg_key(int(id))) if not backgrounds: backgrounds_back = [] backgrounds_front = [] for muscle in exercise.muscles.all(): if muscle.is_front: backgrounds_front.append('images/muscles/main/muscle-%s.svg' % muscle.id) else: backgrounds_back.append('images/muscles/main/muscle-%s.svg' % muscle.id) for muscle in exercise.muscles_secondary.all(): if muscle.is_front: backgrounds_front.append( 'images/muscles/secondary/muscle-%s.svg' % muscle.id) else: backgrounds_back.append( 'images/muscles/secondary/muscle-%s.svg' % muscle.id) # Append the "main" background, with the silhouette of the human body # This has to happen as the last step, so it is rendered behind the muscles. backgrounds_front.append('images/muscles/muscular_system_front.svg') backgrounds_back.append('images/muscles/muscular_system_back.svg') backgrounds = (backgrounds_front, backgrounds_back) cache.set(cache_mapper.get_exercise_muscle_bg_key(int(id)), (backgrounds_front, backgrounds_back)) template_data['muscle_backgrounds_front'] = backgrounds[0] template_data['muscle_backgrounds_back'] = backgrounds[1] # If the user is logged in, load the log and prepare the entries for # rendering in the D3 chart entry_log = [] chart_data = [] if request.user.is_authenticated: logs = WorkoutLog.objects.filter(user=request.user, exercise=exercise) entry_log, chart_data = process_log_entries(logs) template_data['logs'] = entry_log template_data['json'] = chart_data template_data['svg_uuid'] = str(uuid.uuid4()) return ua_aware_render(request, 'exercise/view.html', template_data)
def features(request): ''' Render the features page ''' context = {'allow_registration': settings.WGER_SETTINGS['ALLOW_REGISTRATION'], 'allow_guest_users': settings.WGER_SETTINGS['ALLOW_GUEST_USERS']} return ua_aware_render(request, 'features.html', context)
def overview(request): template_data = {} template_data.update(csrf(request)) plans = NutritionPlan.objects.filter(user=request.user) template_data['plans'] = plans return ua_aware_render(request, 'plan/overview.html', template_data)
def edit(request, pk): ''' Edit a set (its settings actually) ''' set_obj = get_object_or_404(Set, pk=pk) if set_obj.get_owner_object().user != request.user: return HttpResponseForbidden() formsets = [] for exercise in set_obj.exercises.all(): queryset = Setting.objects.filter(set=set_obj, exercise=exercise) formset = SettingFormset(queryset=queryset, prefix='exercise{0}'.format(exercise.id)) formsets.append({'exercise': exercise, 'formset': formset}) if request.method == "POST": formsets = [] for exercise in set_obj.exercises.all(): formset = SettingFormset(request.POST, prefix='exercise{0}'.format(exercise.id)) formsets.append({'exercise': exercise, 'formset': formset}) # If all formsets validate, save them all_valid = True for formset in formsets: if not formset['formset'].is_valid(): all_valid = False if all_valid: for formset in formsets: instances = formset['formset'].save(commit=False) for instance in instances: # If the setting has already a set, we are editing... try: instance.set # Check that we are allowed to do this if instance.get_owner_object().user != request.user: return HttpResponseForbidden() instance.save() # ...if not, create a new setting except ObjectDoesNotExist: instance.set = set_obj instance.order = 1 instance.exercise = formset['exercise'] instance.save() return HttpResponseRedirect( reverse('manager:workout:view', kwargs={'pk': set_obj.get_owner_object().id})) # Other context we need context = {} context['formsets'] = formsets context['form_action'] = reverse('manager:set:edit', kwargs={'pk': pk}) return ua_aware_render(request, 'set/edit.html', context)
def dashboard(request): ''' Show the index page, in our case, the last workout and nutritional plan and the current weight ''' template_data = {} # Load the last workout, either from a schedule or a 'regular' one (current_workout, schedule) = Schedule.objects.get_current_workout(request.user) template_data['current_workout'] = current_workout template_data['schedule'] = schedule # Load the last nutritional plan, if one exists try: plan = NutritionPlan.objects.filter( user=request.user).latest('creation_date') except ObjectDoesNotExist: plan = False template_data['plan'] = plan # Load the last logged weight entry, if one exists try: weight = WeightEntry.objects.filter(user=request.user).latest('date') except ObjectDoesNotExist: weight = False template_data['weight'] = weight template_data['last_weight_entries'] = get_last_entries(request.user) # Format a bit the days so it doesn't have to be done in the template used_days = {} if current_workout: for day in current_workout.day_set.select_related(): for day_of_week in day.day.select_related(): used_days[day_of_week.id] = day.description week_day_result = [] for week in DaysOfWeek.objects.all(): day_has_workout = False if week.id in used_days: day_has_workout = True week_day_result.append( (_(week.day_of_week), used_days[week.id], True)) if not day_has_workout: week_day_result.append((_(week.day_of_week), _('Rest day'), False)) template_data['weekdays'] = week_day_result if plan: # Load the nutritional info template_data['nutritional_info'] = plan.get_nutritional_values() return ua_aware_render(request, 'index.html', template_data)
def overview(request): ''' An overview of all the user's schedules ''' template_data = {} template_data['schedules'] = (Schedule.objects.filter( user=request.user).order_by('-is_active', '-start_date')) return ua_aware_render(request, 'schedule/overview.html', template_data)
def view(request): ''' The BMI calculator detail page ''' context = {} form_data = {'height': request.user.userprofile.height, 'weight': request.user.userprofile.weight} context['form'] = BmiForm(initial=form_data) return helpers.ua_aware_render(request, 'bmi/form.html', context)
def overview(request): ''' An overview of all the user's workouts ''' template_data = {} workouts = Workout.objects.filter(user=request.user) (current_workout, schedule) = Schedule.objects.get_current_workout(request.user) template_data['workouts'] = workouts template_data['current_workout'] = current_workout return ua_aware_render(request, 'workout/overview.html', template_data)
def view(request, pk): ''' Show the workout with the given ID ''' template_data = {} workout = get_object_or_404(Workout, pk=pk) user = workout.user is_owner = request.user == user if not is_owner and not user.userprofile.ro_access: return HttpResponseForbidden() canonical = workout.canonical_representation uid, token = make_token(user) # Create the backgrounds that show what muscles the workout will work on muscles_front = [] muscles_back = [] for i in canonical['muscles']['front']: if i not in muscles_front: muscles_front.append( 'images/muscles/main/muscle-{0}.svg'.format(i)) for i in canonical['muscles']['back']: if i not in muscles_back: muscles_back.append('images/muscles/main/muscle-{0}.svg'.format(i)) for i in canonical['muscles']['frontsecondary']: if i not in muscles_front and i not in canonical['muscles']['front']: muscles_front.append( 'images/muscles/secondary/muscle-{0}.svg'.format(i)) for i in canonical['muscles']['backsecondary']: if i not in muscles_back and i not in canonical['muscles']['back']: muscles_back.append( 'images/muscles/secondary/muscle-{0}.svg'.format(i)) # Append the silhouette of the human body as the last entry so the browser # renders it in the background muscles_front.append('images/muscles/muscular_system_front.svg') muscles_back.append('images/muscles/muscular_system_back.svg') template_data['workout'] = workout template_data['muscle_backgrounds_front'] = muscles_front template_data['muscle_backgrounds_back'] = muscles_back template_data['uid'] = uid template_data['token'] = token template_data['is_owner'] = is_owner template_data['owner_user'] = user template_data['show_shariff'] = is_owner return ua_aware_render(request, 'workout/view.html', template_data)
def view(request, id, slug=None): template_data = {} ingredient = cache.get(cache_mapper.get_ingredient_key(int(id))) if not ingredient: ingredient = get_object_or_404(Ingredient, pk=id) cache.set(cache_mapper.get_ingredient_key(ingredient), ingredient) template_data['ingredient'] = ingredient template_data['form'] = UnitChooserForm(data={'ingredient_id': ingredient.id, 'amount': 100, 'unit': None}) template_data['show_shariff'] = True return ua_aware_render(request, 'ingredient/view.html', template_data)
def view(request, id): ''' Renders a day as shown in the workout overview. This function is to be used with AJAX calls. ''' template_data = {} # Load day and check if its workout belongs to the user day = get_object_or_404(Day, pk=id, training__user=request.user) template_data['day'] = day return ua_aware_render(request, 'day/view.html', template_data)
def view(request): ''' The basal metabolic rate detail page ''' form_data = {'age': request.user.userprofile.age, 'height': request.user.userprofile.height, 'gender': request.user.userprofile.gender, 'weight': request.user.userprofile.weight} context = {} context['form'] = BmrForm(initial=form_data) context['form_activities'] = PhysicalActivitiesForm(instance=request.user.userprofile) context['form_calories'] = DailyCaloriesForm(instance=request.user.userprofile) return ua_aware_render(request, 'rate/form.html', context)
def delete(request, user_pk=None): ''' Delete a user account and all his data, requires password confirmation first If no user_pk is present, the user visiting the URL will be deleted, otherwise a gym administrator is deleting a different user ''' if user_pk: user = get_object_or_404(User, pk=user_pk) form_action = reverse('core:user:delete', kwargs={'user_pk': user_pk}) # Forbidden if the user has not enough rights, doesn't belong to the # gym or is an admin as well. General admins can delete all users. if not request.user.has_perm('gym.manage_gyms') \ and (not request.user.has_perm('gym.manage_gym') or request.user.userprofile.gym_id != user.userprofile.gym_id or user.has_perm('gym.manage_gym') or user.has_perm('gym.gym_trainer') or user.has_perm('gym.manage_gyms')): return HttpResponseForbidden() else: user = request.user form_action = reverse('core:user:delete') form = PasswordConfirmationForm(user=request.user) if request.method == 'POST': form = PasswordConfirmationForm(data=request.POST, user=request.user) if form.is_valid(): user.delete() messages.success( request, _('Account "{0}" was successfully deleted').format( user.username)) if not user_pk: django_logout(request) return HttpResponseRedirect(reverse('software:features')) else: gym_pk = request.user.userprofile.gym_id return HttpResponseRedirect( reverse('gym:gym:user-list', kwargs={'pk': gym_pk})) context = {'form': form, 'user_delete': user, 'form_action': form_action} return ua_aware_render(request, 'user/delete_account.html', context)
def get_formset(request, exercise_pk, reps=Set.DEFAULT_SETS): ''' Returns a formset. This is then rendered inside the new set template ''' exercise = Exercise.objects.get(pk=exercise_pk) SettingFormSet = inlineformset_factory(Set, Setting, can_delete=False, extra=int(reps), fields=SETTING_FORMSET_FIELDS) formset = SettingFormSet(queryset=Setting.objects.none(), prefix='exercise{0}'.format(exercise_pk)) return ua_aware_render(request, "set/formset.html", { 'formset': formset, 'exercise': exercise })
def preferences(request): ''' An overview of all user preferences ''' template_data = {} template_data.update(csrf(request)) redirect = False # Process the preferences form if request.method == 'POST': form = UserPreferencesForm(data=request.POST, instance=request.user.userprofile) form.user = request.user # Save the data if it validates if form.is_valid(): form.save() redirect = True else: form = UserPreferencesForm(instance=request.user.userprofile) # Process the email form if request.method == 'POST': email_form = UserPersonalInformationForm(data=request.POST, instance=request.user) if email_form.is_valid() and redirect: email_form.save() redirect = True else: redirect = False else: email_form = UserPersonalInformationForm(instance=request.user) template_data['form'] = form template_data['email_form'] = email_form if redirect: messages.success(request, _('Settings successfully updated')) return HttpResponseRedirect(reverse('core:user:preferences')) else: return ua_aware_render(request, 'user/preferences.html', template_data)
def day(request, username, year, month, day): ''' Show the logs for a single day ''' context = {} is_owner, user = check_access(request.user, username) try: date = datetime.date(int(year), int(month), int(day)) except ValueError as e: logger.error("Error on date: {0}".format(e)) return HttpResponseForbidden() context['logs'] = group_log_entries(user, date.year, date.month, date.day) context['date'] = date context['owner_user'] = user context['is_owner'] = is_owner context['show_shariff'] = is_owner and user.userprofile.ro_access return ua_aware_render(request, 'calendar/day.html', context)
def gym_new_user_info(request): ''' Shows info about a newly created user ''' if not request.user.is_authenticated: return HttpResponseForbidden() if not request.session.get('gym.user'): return HttpResponseRedirect(reverse('gym:gym:list')) if not request.user.has_perm('gym.manage_gyms') \ and not request.user.has_perm('gym.manage_gym'): return HttpResponseForbidden() context = { 'new_user': get_object_or_404(User, pk=request.session['gym.user']['user_pk']), 'password': request.session['gym.user']['password'] } return ua_aware_render(request, 'gym/new_user.html', context)
def view(request, id): ''' Show the nutrition plan with the given ID ''' template_data = {} plan = get_object_or_404(NutritionPlan, pk=id) user = plan.user is_owner = request.user == user if not is_owner and not user.userprofile.ro_access: return HttpResponseForbidden() uid, token = make_token(user) # Load the language and pass it to the template language = load_language() template_data['language'] = language template_data['MEALITEM_WEIGHT_GRAM'] = MEALITEM_WEIGHT_GRAM template_data['MEALITEM_WEIGHT_UNIT'] = MEALITEM_WEIGHT_UNIT # Get the nutritional info template_data['plan'] = plan template_data['nutritional_data'] = \ plan.get_nutritional_values() # Get the weight entry used template_data['weight_entry'] = plan.get_closest_weight_entry() # Tokens for the links template_data['uid'] = uid template_data['token'] = token template_data['owner_user'] = user template_data['is_owner'] = is_owner template_data['show_shariff'] = is_owner return ua_aware_render(request, 'plan/view.html', template_data)
def reset_user_password(request, user_pk): ''' Resets the password of the selected user to random password ''' user = get_object_or_404(User, pk=user_pk) if not request.user.is_authenticated: return HttpResponseForbidden() if not request.user.has_perm('gym.manage_gyms') \ and not request.user.has_perm('gym.manage_gym'): return HttpResponseForbidden() if request.user.has_perm('gym.manage_gym') \ and request.user.userprofile.gym != user.userprofile.gym: return HttpResponseForbidden() password = password_generator() user.set_password(password) user.save() context = {'mod_user': user, 'password': password} return ua_aware_render(request, 'gym/reset_user_password.html', context)
def api_key(request): ''' Allows the user to generate an API key for the REST API ''' context = {} context.update(csrf(request)) try: token = Token.objects.get(user=request.user) except Token.DoesNotExist: token = False if request.GET.get('new_key'): if token: token.delete() token = Token.objects.create(user=request.user) # Redirect to get rid of the GET parameter return HttpResponseRedirect(reverse('core:user:api-key')) context['token'] = token return ua_aware_render(request, 'user/api_key.html', context)
def add(request, pk): ''' Add a new workout log ''' template_data = {} template_data.update(csrf(request)) # Load the day and check ownership day = get_object_or_404(Day, pk=pk) if day.get_owner_object().user != request.user: return HttpResponseForbidden() # We need several lists here because we need to assign specific form to each # exercise: the entries for weight and repetitions have no indicator to which # exercise they belong besides the form-ID, from Django's formset counter = 0 total_sets = 0 exercise_list = {} form_to_exercise = {} for exercise_set in day.set_set.all(): for exercise in exercise_set.exercises.all(): # Maximum possible values total_sets += int(exercise_set.sets) counter_before = counter counter = counter + int(exercise_set.sets) - 1 form_id_range = range(counter_before, counter + 1) # Add to list exercise_list[exercise.id] = { 'obj': exercise, 'sets': int(exercise_set.sets), 'form_ids': form_id_range } counter += 1 # Helper mapping form-ID <--> Exercise for id in form_id_range: form_to_exercise[id] = exercise # Define the formset here because now we know the value to pass to 'extra' WorkoutLogFormSet = modelformset_factory(WorkoutLog, form=WorkoutLogForm, exclude=('date', 'workout'), extra=total_sets) # Process the request if request.method == 'POST': # Make a copy of the POST data and go through it. The reason for this is # that the form expects a value for the exercise which is not present in # the form (for space and usability reasons) post_copy = request.POST.copy() for form_id in form_to_exercise: if post_copy.get('form-%s-weight' % form_id) or post_copy.get( 'form-%s-reps' % form_id): post_copy['form-%s-exercise' % form_id] = form_to_exercise[form_id].id # Pass the new data to the forms formset = WorkoutLogFormSet(data=post_copy) dateform = HelperDateForm(data=post_copy) session_form = HelperWorkoutSessionForm(data=post_copy) # If all the data is valid, save and redirect to log overview page if dateform.is_valid() and session_form.is_valid( ) and formset.is_valid(): log_date = dateform.cleaned_data['date'] if WorkoutSession.objects.filter(user=request.user, date=log_date).exists(): session = WorkoutSession.objects.get(user=request.user, date=log_date) session_form = HelperWorkoutSessionForm(data=post_copy, instance=session) # Save the Workout Session only if there is not already one for this date instance = session_form.save(commit=False) if not WorkoutSession.objects.filter(user=request.user, date=log_date).exists(): instance.date = log_date instance.user = request.user instance.workout = day.training else: session = WorkoutSession.objects.get(user=request.user, date=log_date) instance.instance = session instance.save() # Log entries (only the ones with actual content) instances = [i for i in formset.save(commit=False) if i.reps] for instance in instances: if not instance.weight: instance.weight = 0 instance.user = request.user instance.workout = day.training instance.date = log_date instance.save() return HttpResponseRedirect( reverse('manager:log:log', kwargs={'pk': day.training_id})) else: # Initialise the formset with a queryset that won't return any objects # (we only add new logs here and that seems to be the fastest way) user_weight_unit = 1 if request.user.userprofile.use_metric else 2 formset = WorkoutLogFormSet(queryset=WorkoutLog.objects.none(), initial=[{ 'weight_unit': user_weight_unit, 'repetition_unit': 1 } for x in range(0, total_sets)]) dateform = HelperDateForm(initial={'date': datetime.date.today()}) # Depending on whether there is already a workout session for today, update # the current one or create a new one (this will be the most usual case) if WorkoutSession.objects.filter(user=request.user, date=datetime.date.today()).exists(): session = WorkoutSession.objects.get(user=request.user, date=datetime.date.today()) session_form = HelperWorkoutSessionForm(instance=session) else: session_form = HelperWorkoutSessionForm() # Pass the correct forms to the exercise list for exercise in exercise_list: form_id_from = min(exercise_list[exercise]['form_ids']) form_id_to = max(exercise_list[exercise]['form_ids']) exercise_list[exercise]['forms'] = formset[form_id_from:form_id_to + 1] template_data['day'] = day template_data['exercises'] = exercise_list template_data['exercise_list'] = exercise_list template_data['formset'] = formset template_data['dateform'] = dateform template_data['session_form'] = session_form template_data['form_action'] = reverse('manager:day:log', kwargs={'pk': pk}) return ua_aware_render(request, 'day/log.html', template_data)
def copy_workout(request, pk): ''' Makes a copy of a workout ''' workout = get_object_or_404(Workout, pk=pk) user = workout.user is_owner = request.user == user if not is_owner and not user.userprofile.ro_access: return HttpResponseForbidden() # Process request if request.method == 'POST': workout_form = WorkoutCopyForm(request.POST) if workout_form.is_valid(): # Copy workout days = workout.day_set.all() workout_copy = workout workout_copy.pk = None workout_copy.comment = workout_form.cleaned_data['comment'] workout_copy.user = request.user workout_copy.save() # Copy the days for day in days: sets = day.set_set.all() day_copy = day days_of_week = [i for i in day.day.all()] day_copy.pk = None day_copy.training = workout_copy day_copy.save() for i in days_of_week: day_copy.day.add(i) day_copy.save() # Copy the sets for current_set in sets: current_set_id = current_set.id exercises = current_set.exercises.all() current_set_copy = current_set current_set_copy.pk = None current_set_copy.exerciseday = day_copy current_set_copy.save() # Exercises has Many2Many relationship current_set_copy.exercises.set(exercises) # Go through the exercises for exercise in exercises: settings = exercise.setting_set.filter( set_id=current_set_id) # Copy the settings for setting in settings: setting_copy = setting setting_copy.pk = None setting_copy.set = current_set_copy setting_copy.save() return HttpResponseRedirect( reverse('manager:workout:view', kwargs={'pk': workout.id})) else: workout_form = WorkoutCopyForm({'comment': workout.comment}) template_data = {} template_data.update(csrf(request)) template_data['title'] = _('Copy workout') template_data['form'] = workout_form template_data['form_action'] = reverse('manager:workout:copy', kwargs={'pk': workout.id}) template_data['form_fields'] = [workout_form['comment']] template_data['submit_text'] = _('Copy') template_data[ 'extend_template'] = 'base_empty.html' if request.is_ajax( ) else 'base.html' return ua_aware_render(request, 'form.html', template_data)
def timer(request, day_pk): ''' The timer view ("gym mode") for a workout ''' day = get_object_or_404(Day, pk=day_pk, training__user=request.user) canonical_day = day.canonical_representation context = {} step_list = [] last_log = LastWeightHelper(request.user) # Go through the workout day and create the individual 'pages' for set_dict in canonical_day['set_list']: if not set_dict['is_superset']: for exercise_dict in set_dict['exercise_list']: exercise = exercise_dict['obj'] for key, element in enumerate(exercise_dict['reps_list']): reps = exercise_dict['reps_list'][key] rep_unit = exercise_dict['repetition_units'][key] weight_unit = exercise_dict['weight_units'][key] default_weight = last_log.get_last_weight( exercise, reps, exercise_dict['weight_list'][key]) step_list.append({ 'current_step': uuid.uuid4().hex, 'step_percent': 0, 'step_nr': len(step_list) + 1, 'exercise': exercise, 'type': 'exercise', 'reps': reps, 'rep_unit': rep_unit, 'weight': default_weight, 'weight_unit': weight_unit }) if request.user.userprofile.timer_active: step_list.append({ 'current_step': uuid.uuid4().hex, 'step_percent': 0, 'step_nr': len(step_list) + 1, 'type': 'pause', 'time': request.user.userprofile.timer_pause }) # Supersets need extra work to group the exercises and reps together else: total_reps = len(set_dict['exercise_list'][0]['reps_list']) for i in range(0, total_reps): for exercise_dict in set_dict['exercise_list']: reps = exercise_dict['reps_list'][i] rep_unit = exercise_dict['repetition_units'][i] weight_unit = exercise_dict['weight_units'][i] default_weight = exercise_dict['weight_list'][i] exercise = exercise_dict['obj'] step_list.append({ 'current_step': uuid.uuid4().hex, 'step_percent': 0, 'step_nr': len(step_list) + 1, 'exercise': exercise, 'type': 'exercise', 'reps': reps, 'rep_unit': rep_unit, 'weight_unit': weight_unit, 'weight': last_log.get_last_weight(exercise, reps, default_weight) }) if request.user.userprofile.timer_active: step_list.append({ 'current_step': uuid.uuid4().hex, 'step_percent': 0, 'step_nr': len(step_list) + 1, 'type': 'pause', 'time': 90 }) # Remove the last pause step as it is not needed. If the list is empty, # because the user didn't add any repetitions to any exercise, do nothing try: step_list.pop() except IndexError: pass # Go through the page list and calculate the correct value for step_percent for i, s in enumerate(step_list): step_list[i]['step_percent'] = (i + 1) * 100.0 / len(step_list) # Depending on whether there is already a workout session for today, update # the current one or create a new one (this will be the most usual case) if WorkoutSession.objects.filter(user=request.user, date=datetime.date.today()).exists(): session = WorkoutSession.objects.get(user=request.user, date=datetime.date.today()) url = reverse('manager:session:edit', kwargs={'pk': session.pk}) session_form = WorkoutSessionHiddenFieldsForm(instance=session) else: today = datetime.date.today() url = reverse('manager:session:add', kwargs={ 'workout_pk': day.training_id, 'year': today.year, 'month': today.month, 'day': today.day }) session_form = WorkoutSessionHiddenFieldsForm() # Render template context['day'] = day context['step_list'] = step_list context['canonical_day'] = canonical_day context['workout'] = day.training context['session_form'] = session_form context['form_action'] = url context['weight_units'] = WeightUnit.objects.all() context['repetition_units'] = RepetitionUnit.objects.all() return ua_aware_render(request, 'workout/timer.html', context)
def create(request, day_pk): ''' Creates a new set. This view handles both the set form and the corresponding settings formsets ''' day = get_object_or_404(Day, pk=day_pk) if day.get_owner_object().user != request.user: return HttpResponseForbidden() # Select the correct form depending on the user-agent. # The difference is that the mobile form doesn't use the autocompleter for # exercises, but 2 dropdowns, one to filter by category and one to select # the exercises themselves. user_agent = get_user_agent(request) if user_agent.is_mobile: form_class = SetFormMobile else: form_class = SetForm context = {} formsets = [] form = form_class(initial={'sets': Set.DEFAULT_SETS}) # For the mobile dropdown list we need to manually filter the exercises # by language and status if user_agent.is_mobile: languages = load_item_languages(LanguageConfig.SHOW_ITEM_EXERCISES) form.fields['exercise_list'].queryset = Exercise.objects.accepted() \ .filter(language__in=languages) # If the form and all formsets validate, save them if request.method == "POST": form = form_class(request.POST) if form.is_valid(): for exercise in form.cleaned_data['exercises']: formset = SettingFormset(request.POST, queryset=Setting.objects.none(), prefix='exercise{0}'.format( exercise.id)) formsets.append({'exercise': exercise, 'formset': formset}) all_valid = True for formset in formsets: if not formset['formset'].is_valid(): all_valid = False if form.is_valid() and all_valid: # Manually take care of the order, TODO: better move this to the model max_order = day.set_set.select_related().aggregate( models.Max('order')) form.instance.order = (max_order['order__max'] or 0) + 1 form.instance.exerciseday = day set_obj = form.save() for formset in formsets: instances = formset['formset'].save(commit=False) for instance in instances: instance.set = set_obj instance.order = 1 instance.exercise = formset['exercise'] instance.save() return HttpResponseRedirect( reverse('manager:workout:view', kwargs={'pk': day.get_owner_object().id})) else: logger.debug(form.errors) # Other context we need context['form'] = form context['day'] = day context['max_sets'] = Set.MAX_SETS context['formsets'] = formsets context['form_action'] = reverse('manager:set:add', kwargs={'day_pk': day_pk}) context['extend_template'] = 'base_empty.html' if request.is_ajax( ) else 'base.html' return ua_aware_render(request, 'set/add.html', context)
def gym_permissions_user_edit(request, user_pk): ''' Edits the permissions of a gym member ''' member = get_object_or_404(User, pk=user_pk) user = request.user if not user.is_authenticated: return HttpResponseForbidden() if not user.has_perm('gym.manage_gyms') and not user.has_perm( 'gym.manage_gym'): return HttpResponseForbidden() if user.has_perm('gym.manage_gym' ) and user.userprofile.gym != member.userprofile.gym: return HttpResponseForbidden() # Calculate available user permissions form_group_permission = get_permission_list(user) if request.method == 'POST': form = GymUserPermissionForm(available_roles=form_group_permission, data=request.POST) if form.is_valid(): # Remove the user from all gym permission groups member.groups.remove(Group.objects.get(name='gym_member')) member.groups.remove(Group.objects.get(name='gym_trainer')) member.groups.remove(Group.objects.get(name='gym_manager')) member.groups.remove(Group.objects.get(name='general_gym_manager')) # Set appropriate permission groups if 'user' in form.cleaned_data['role']: member.groups.add(Group.objects.get(name='gym_member')) if 'trainer' in form.cleaned_data['role']: member.groups.add(Group.objects.get(name='gym_trainer')) if 'admin' in form.cleaned_data['role']: member.groups.add(Group.objects.get(name='gym_manager')) if 'manager' in form.cleaned_data['role']: member.groups.add( Group.objects.get(name='general_gym_manager')) return HttpResponseRedirect( reverse('gym:gym:user-list', kwargs={'pk': member.userprofile.gym.pk})) else: initial_data = {} if member.groups.filter(name='gym_member').exists(): initial_data['user'] = True if member.groups.filter(name='gym_trainer').exists(): initial_data['trainer'] = True if member.groups.filter(name='gym_manager').exists(): initial_data['admin'] = True if member.groups.filter(name='general_gym_manager').exists(): initial_data['manager'] = True form = GymUserPermissionForm(initial={'role': initial_data}, available_roles=form_group_permission) context = {} context['title'] = member.get_full_name() context['form'] = form context['form_action'] = reverse('gym:gym:edit-user-permission', kwargs={'user_pk': member.pk}) context['extend_template'] = 'base_empty.html' if request.is_ajax( ) else 'base.html' context['submit_text'] = 'Save' return ua_aware_render(request, 'form.html', context)
def registration(request): ''' A form to allow for registration of new users ''' # If global user registration is deactivated, redirect if not settings.WGER_SETTINGS['ALLOW_REGISTRATION']: return HttpResponseRedirect(reverse('software:features')) template_data = {} template_data.update(csrf(request)) # Don't use captcha when registering through an app is_app = check_request_amazon(request) or check_request_android(request) FormClass = RegistrationFormNoCaptcha if is_app else RegistrationForm # Don't show captcha if the global parameter is false if not settings.WGER_SETTINGS['USE_RECAPTCHA']: FormClass = RegistrationFormNoCaptcha # Redirect regular users, in case they reached the registration page if request.user.is_authenticated and not request.user.userprofile.is_temporary: return HttpResponseRedirect(reverse('core:dashboard')) if request.method == 'POST': form = FormClass(data=request.POST) # If the data is valid, log in and redirect if form.is_valid(): username = form.cleaned_data['username'] password = form.cleaned_data['password1'] email = form.cleaned_data['email'] user = User.objects.create_user(username, email, password) user.save() # Pre-set some values of the user's profile language = Language.objects.get( short_name=translation.get_language()) user.userprofile.notification_language = language # Set default gym, if needed gym_config = GymConfig.objects.get(pk=1) if gym_config.default_gym: user.userprofile.gym = gym_config.default_gym # Create gym user configuration object config = GymUserConfig() config.gym = gym_config.default_gym config.user = user config.save() user.userprofile.save() user = authenticate(username=username, password=password) django_login(request, user) messages.success(request, _('You were successfully registered')) return HttpResponseRedirect(reverse('core:dashboard')) else: form = FormClass() template_data['form'] = form template_data['title'] = _('Register') template_data['form_fields'] = [i for i in form] template_data['form_action'] = reverse('core:user:registration') template_data['submit_text'] = _('Register') template_data['extend_template'] = 'base.html' return ua_aware_render(request, 'form.html', template_data)