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)
