595 lines
23 KiB
Python
595 lines
23 KiB
Python
import calendar
|
|
from datetime import timedelta
|
|
|
|
from django.contrib import messages
|
|
from django.contrib.auth import login, logout
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.http import Http404, HttpResponse, JsonResponse
|
|
from django.shortcuts import get_object_or_404, redirect, render
|
|
from django.urls import reverse, reverse_lazy
|
|
from django.utils import timezone
|
|
from django.utils.dateparse import parse_date
|
|
from django.views.decorators.http import require_http_methods, require_POST
|
|
from django.contrib.auth.mixins import LoginRequiredMixin
|
|
from django.views.generic import CreateView, DeleteView, DetailView, ListView, TemplateView, UpdateView
|
|
|
|
from .forms import (
|
|
DailyPlannerForm, FastingSettingsForm, RegistrationForm, SickDaySettingsForm, SleepCheckInForm, TimeZoneSettingsForm,
|
|
NeckHeadacheCheckInForm, TaskForm, UserSettingsForm, WorkoutForm,
|
|
)
|
|
from .models import FastingPeriod, FastingSettings, NeckHeadacheCheckIn, SickDaySettings, SleepCheckIn, Task, UserSettings, Workout
|
|
from .services.checkins import (
|
|
ANNUAL_PHYSIOTHERAPY_SESSION_ALLOWANCE, LOW_PAIN_STREAK_THRESHOLD, calculate_check_in_streaks,
|
|
)
|
|
from .services.fasting import (
|
|
configure_fasting, current_fasting_phase, set_fasting_tracking_enabled,
|
|
synchronize_fasting_periods,
|
|
)
|
|
from .services.scheduling import daily_recommendations, duration_budget_for_energy
|
|
from .services.workouts import toggle_workout_completion, workouts_for_day
|
|
from .timezones import localdate_for_user
|
|
from .services.weather import (
|
|
WEATHER_ICON_NAMES, WEATHER_LABELS, forecast_for_user_on_date, forecasts_for_user,
|
|
)
|
|
|
|
|
|
def workout_context(user, selected_date=None):
|
|
selected_date = selected_date or timezone.localdate()
|
|
summary = workouts_for_day(user, selected_date)
|
|
return {
|
|
'workouts': summary.workouts,
|
|
'workout_date': selected_date,
|
|
'workout_calories_total': summary.calories_total,
|
|
'completed_workouts_without_calories': summary.completed_without_calories,
|
|
}
|
|
|
|
|
|
def render_workout_section(request):
|
|
return render(request, 'planner/partials/workout_section.html', workout_context(request.user))
|
|
|
|
|
|
def selected_check_in_date(value, user=None):
|
|
return parse_date(value) if value else (localdate_for_user(user) if user else timezone.localdate())
|
|
|
|
|
|
def categories_for_user(user, query=""):
|
|
"""Return each of a user's category names once, ignoring case and outer space."""
|
|
needle = query.strip().casefold()
|
|
categories = []
|
|
seen = set()
|
|
for category in Task.objects.filter(owner=user).exclude(category="").order_by("pk").values_list("category", flat=True):
|
|
normalized = category.strip()
|
|
key = normalized.casefold()
|
|
if normalized and key not in seen and (not needle or key.startswith(needle)):
|
|
seen.add(key)
|
|
categories.append(normalized)
|
|
return categories
|
|
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(["GET"])
|
|
def category_suggestions(request):
|
|
query = request.GET.get("q", "")[:100]
|
|
return JsonResponse({"categories": categories_for_user(request.user, query)})
|
|
|
|
|
|
def pain_level(score):
|
|
if score == 0:
|
|
return 'zero'
|
|
if score <= LOW_PAIN_STREAK_THRESHOLD:
|
|
return 'low'
|
|
if score <= 5:
|
|
return 'moderate'
|
|
if score <= 7:
|
|
return 'high'
|
|
return 'severe'
|
|
|
|
|
|
def check_in_context(user, selected_date=None, form=None, sleep_form=None, active_tab='pain'):
|
|
active_tab = active_tab if active_tab in {'pain', 'sleep'} else 'pain'
|
|
today = localdate_for_user(user)
|
|
selected_date = selected_date or today
|
|
check_ins = list(
|
|
NeckHeadacheCheckIn.objects.filter(user=user, check_in_date__lte=today)
|
|
)
|
|
sleep_check_ins = list(
|
|
SleepCheckIn.objects.filter(user=user, wake_up_date__lte=today)
|
|
)
|
|
check_in_by_date = {check_in.check_in_date: check_in for check_in in check_ins}
|
|
sleep_check_in_by_date = {check_in.wake_up_date: check_in for check_in in sleep_check_ins}
|
|
selected_check_in = check_in_by_date.get(selected_date)
|
|
selected_sleep_check_in = sleep_check_in_by_date.get(selected_date)
|
|
|
|
if form is None:
|
|
initial = {'check_in_date': selected_date}
|
|
if selected_check_in is None:
|
|
initial.update(neck_pain_severity=0, headache_severity=0)
|
|
form = NeckHeadacheCheckInForm(instance=selected_check_in, initial=initial, user=user)
|
|
if sleep_form is None:
|
|
sleep_form = SleepCheckInForm(
|
|
instance=selected_sleep_check_in, initial={'wake_up_date': selected_date}, user=user
|
|
)
|
|
|
|
calendar_weeks = []
|
|
for week in calendar.Calendar(firstweekday=0).monthdatescalendar(
|
|
selected_date.year, selected_date.month
|
|
):
|
|
calendar_week = []
|
|
for day in week:
|
|
check_in = check_in_by_date.get(day)
|
|
sleep_check_in = sleep_check_in_by_date.get(day)
|
|
if check_in is None:
|
|
label = f'{day:%A, %d %B}: pain not recorded'
|
|
highest_score = None
|
|
level = 'unrecorded'
|
|
else:
|
|
highest_score = max(
|
|
check_in.neck_pain_severity, check_in.headache_severity
|
|
)
|
|
level = pain_level(highest_score)
|
|
label = (
|
|
f'{day:%A, %d %B}: neck pain {check_in.neck_pain_severity} of 10; '
|
|
f'headache {check_in.headache_severity} of 10'
|
|
)
|
|
if check_in.had_physiotherapy:
|
|
label += '; physiotherapy session'
|
|
if sleep_check_in is not None:
|
|
label += f'; sleep rested {sleep_check_in.rested_score} of 10'
|
|
if sleep_check_in.watch_sleep_score is not None:
|
|
label += f'; watch sleep score {sleep_check_in.watch_sleep_score} percent'
|
|
calendar_week.append({
|
|
'date': day,
|
|
'check_in': check_in,
|
|
'sleep_check_in': sleep_check_in,
|
|
'highest_score': highest_score,
|
|
'level': level,
|
|
'label': label,
|
|
'is_today': day == today,
|
|
'is_selected': day == selected_date,
|
|
'is_outside_month': day.month != selected_date.month,
|
|
})
|
|
calendar_weeks.append(calendar_week)
|
|
|
|
month_start = selected_date.replace(day=1)
|
|
return {
|
|
'check_in_form': form,
|
|
'sleep_check_in_form': sleep_form,
|
|
'check_in_selected_date': selected_date,
|
|
'check_in_today': today,
|
|
'check_in_calendar_weeks': calendar_weeks,
|
|
'check_in_previous_month': month_start - timedelta(days=1),
|
|
'check_in_next_month': (month_start + timedelta(days=32)).replace(day=1),
|
|
'check_in_streaks': calculate_check_in_streaks(check_ins, today),
|
|
'check_in_streak_threshold': LOW_PAIN_STREAK_THRESHOLD,
|
|
'physio_sessions_this_year': sum(
|
|
check_in.had_physiotherapy and check_in.check_in_date.year == today.year
|
|
for check_in in check_ins
|
|
),
|
|
'annual_physio_session_allowance': ANNUAL_PHYSIOTHERAPY_SESSION_ALLOWANCE,
|
|
'sleep_check_in_trend': sleep_check_ins[:14],
|
|
'check_in_active_tab': active_tab,
|
|
}
|
|
|
|
|
|
def render_check_in_panel(request, selected_date=None, form=None, sleep_form=None, active_tab='pain'):
|
|
return render(
|
|
request,
|
|
'planner/partials/neck_headache_checkin.html',
|
|
check_in_context(request.user, selected_date, form, sleep_form, active_tab),
|
|
)
|
|
|
|
|
|
def add_predicted_weather(user, tasks):
|
|
"""Attach display-only normalized forecasts without adding per-task HTTP calls."""
|
|
forecast_by_date = {forecast.forecast_date: forecast for forecast in (forecasts_for_user(user) or [])}
|
|
today = timezone.localdate()
|
|
for task in tasks:
|
|
for item in (task, *task.subtasks.all()):
|
|
if item.scheduled_for >= today:
|
|
forecast = forecast_by_date.get(item.scheduled_for)
|
|
if forecast is not None:
|
|
item.predicted_weather = forecast
|
|
item.predicted_weather_icon = WEATHER_ICON_NAMES[forecast.condition]
|
|
item.predicted_weather_label = WEATHER_LABELS[forecast.condition]
|
|
return tasks
|
|
|
|
|
|
def dashboard_weather_context(user):
|
|
forecast = forecast_for_user_on_date(user, timezone.localdate())
|
|
profile = UserSettings.objects.filter(user=user).only('latitude').first()
|
|
if forecast is None:
|
|
return {'weather_forecast': None, 'weather_location_configured': bool(profile and profile.latitude is not None)}
|
|
return {
|
|
'weather_forecast': forecast,
|
|
'weather_icon': WEATHER_ICON_NAMES[forecast.condition],
|
|
'weather_label': WEATHER_LABELS[forecast.condition],
|
|
'weather_location_configured': True,
|
|
}
|
|
|
|
|
|
def fasting_widget_context(user):
|
|
"""Fetch widget state; schedule decisions remain in the fasting service."""
|
|
fasting_settings = FastingSettings.objects.filter(user=user).first()
|
|
if fasting_settings is None:
|
|
return {'fasting_settings': None, 'fasting_history': []}
|
|
synchronize_fasting_periods(fasting_settings)
|
|
context = {
|
|
'fasting_settings': fasting_settings,
|
|
'fasting_history': FastingPeriod.objects.filter(user=user)[:3],
|
|
}
|
|
if fasting_settings.enabled:
|
|
context['fasting_phase'] = current_fasting_phase(fasting_settings)
|
|
return context
|
|
|
|
|
|
def render_fasting_widget(request):
|
|
return render(request, 'planner/partials/fasting_widget.html', fasting_widget_context(request.user))
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(['GET'])
|
|
def fasting_widget(request):
|
|
return render_fasting_widget(request)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(['GET', 'POST'])
|
|
def fasting_configure(request):
|
|
fasting_settings = FastingSettings.objects.filter(user=request.user).first()
|
|
if request.method == 'POST':
|
|
form = FastingSettingsForm(request.POST, instance=fasting_settings)
|
|
if form.is_valid():
|
|
configure_fasting(
|
|
request.user,
|
|
enabled=form.cleaned_data['enabled'],
|
|
fasting_start_time=form.cleaned_data['fasting_start_time'],
|
|
fasting_duration_minutes=form.cleaned_data['fasting_duration_minutes'],
|
|
)
|
|
return render_fasting_widget(request)
|
|
else:
|
|
form = FastingSettingsForm(instance=fasting_settings)
|
|
return render(request, 'planner/partials/fasting_configuration.html', {'form': form})
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def fasting_toggle_tracking(request):
|
|
fasting_settings = FastingSettings.objects.filter(user=request.user).first()
|
|
if fasting_settings is None:
|
|
raise Http404('Fasting tracking has not been configured.')
|
|
set_fasting_tracking_enabled(fasting_settings, not fasting_settings.enabled)
|
|
return render_fasting_widget(request)
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(['GET'])
|
|
def neck_headache_checkin_panel(request):
|
|
selected_date = selected_check_in_date(request.GET.get('date'), request.user)
|
|
return render_check_in_panel(request, selected_date, active_tab=request.GET.get('tab', 'pain'))
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def save_neck_headache_checkin(request):
|
|
selected_date = selected_check_in_date(request.POST.get('check_in_date'), request.user)
|
|
existing = NeckHeadacheCheckIn.objects.filter(
|
|
user=request.user, check_in_date=selected_date
|
|
).first()
|
|
form = NeckHeadacheCheckInForm(request.POST, instance=existing, user=request.user)
|
|
if form.is_valid():
|
|
check_in = form.save(commit=False)
|
|
check_in.user = request.user
|
|
check_in.save()
|
|
if request.headers.get('HX-Request') == 'true':
|
|
return render_check_in_panel(request, check_in.check_in_date)
|
|
return redirect(
|
|
reverse('planner:task-list') + '?check_in_date=' + check_in.check_in_date.isoformat()
|
|
)
|
|
return render_check_in_panel(request, selected_date, form)
|
|
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def save_sleep_checkin(request):
|
|
selected_date = selected_check_in_date(request.POST.get('wake_up_date'), request.user)
|
|
existing = SleepCheckIn.objects.filter(
|
|
user=request.user, wake_up_date=selected_date
|
|
).first()
|
|
form = SleepCheckInForm(request.POST, instance=existing, user=request.user)
|
|
if form.is_valid():
|
|
check_in = form.save(commit=False)
|
|
check_in.user = request.user
|
|
check_in.save()
|
|
if request.headers.get('HX-Request') == 'true':
|
|
return render_check_in_panel(request, check_in.wake_up_date, active_tab='sleep')
|
|
return redirect(
|
|
reverse('planner:task-list') + '?check_in_date=' + check_in.wake_up_date.isoformat()
|
|
)
|
|
return render_check_in_panel(request, selected_date, sleep_form=form, active_tab='sleep')
|
|
|
|
|
|
class OwnedTaskQuerysetMixin(LoginRequiredMixin):
|
|
"""Constrain every normal task endpoint to the authenticated owner."""
|
|
|
|
def get_queryset(self):
|
|
return Task.objects.filter(owner=self.request.user).prefetch_related('subtasks')
|
|
|
|
|
|
class TaskListView(LoginRequiredMixin, ListView):
|
|
model = Task
|
|
context_object_name = 'tasks'
|
|
template_name = 'planner/task_list.html'
|
|
|
|
def get_queryset(self):
|
|
queryset = Task.objects.filter(owner=self.request.user, parent_task__isnull=True).prefetch_related('subtasks')
|
|
status = self.request.GET.get('status')
|
|
if status == 'active':
|
|
queryset = queryset.filter(is_active=True)
|
|
elif status == 'inactive':
|
|
queryset = queryset.filter(is_active=False)
|
|
return queryset
|
|
|
|
def get_template_names(self):
|
|
if self.request.headers.get('HX-Request') == 'true':
|
|
return ['planner/partials/task_list_content.html']
|
|
return [self.template_name]
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context['tasks'] = add_predicted_weather(self.request.user, context['tasks'])
|
|
context['current_filter'] = self.request.GET.get('status', 'all')
|
|
context.update(fasting_widget_context(self.request.user))
|
|
context.update(dashboard_weather_context(self.request.user))
|
|
context.update(workout_context(self.request.user))
|
|
context.update(check_in_context(
|
|
self.request.user, selected_check_in_date(self.request.GET.get('check_in_date'), self.request.user),
|
|
active_tab=self.request.GET.get('wellbeing_tab', 'pain')
|
|
))
|
|
return context
|
|
|
|
|
|
class DailyPlannerView(LoginRequiredMixin, TemplateView):
|
|
template_name = 'planner/daily_planner.html'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
default_values = {'selected_date': timezone.localdate().isoformat(), 'energy_level': '3'}
|
|
form = DailyPlannerForm(self.request.GET or default_values)
|
|
context['form'] = form
|
|
context['recommendations'] = []
|
|
if form.is_valid():
|
|
selected_date = form.cleaned_data['selected_date']
|
|
energy_level = form.cleaned_data['energy_level']
|
|
sick_day_settings = SickDaySettings.objects.filter(user=self.request.user).first()
|
|
context.update(
|
|
selected_date=selected_date,
|
|
energy_level=energy_level,
|
|
duration_budget=duration_budget_for_energy(energy_level),
|
|
recommendations=daily_recommendations(
|
|
self.request.user, selected_date, energy_level, sick_day_settings
|
|
),
|
|
)
|
|
return context
|
|
|
|
|
|
class TaskDetailView(OwnedTaskQuerysetMixin, DetailView):
|
|
context_object_name = 'task'
|
|
template_name = 'planner/task_detail.html'
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
add_predicted_weather(self.request.user, [context['task']])
|
|
return context
|
|
|
|
|
|
class TaskCreateView(LoginRequiredMixin, CreateView):
|
|
model = Task
|
|
form_class = TaskForm
|
|
template_name = 'planner/task_form.html'
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
kwargs['owner'] = self.request.user
|
|
return kwargs
|
|
|
|
def get_template_names(self):
|
|
if self.request.headers.get('HX-Request') == 'true':
|
|
return ['planner/partials/task_create_panel.html']
|
|
return [self.template_name]
|
|
|
|
def form_valid(self, form):
|
|
form.instance.owner = self.request.user
|
|
response = super().form_valid(form)
|
|
if self.request.headers.get('HX-Request') == 'true':
|
|
tasks = Task.objects.filter(owner=self.request.user, parent_task__isnull=True).prefetch_related('subtasks')
|
|
return render(self.request, 'planner/partials/task_list_content.html', {'tasks': add_predicted_weather(self.request.user, tasks)})
|
|
return response
|
|
|
|
|
|
class TaskUpdateView(OwnedTaskQuerysetMixin, UpdateView):
|
|
form_class = TaskForm
|
|
template_name = 'planner/task_form.html'
|
|
|
|
def get_form_kwargs(self):
|
|
kwargs = super().get_form_kwargs()
|
|
kwargs['owner'] = self.request.user
|
|
return kwargs
|
|
|
|
|
|
class TaskDeleteView(OwnedTaskQuerysetMixin, DeleteView):
|
|
context_object_name = 'task'
|
|
template_name = 'planner/task_confirm_delete.html'
|
|
success_url = reverse_lazy('planner:task-list')
|
|
|
|
|
|
class OwnedWorkoutQuerysetMixin(LoginRequiredMixin):
|
|
def get_queryset(self):
|
|
return Workout.objects.filter(owner=self.request.user)
|
|
|
|
|
|
class WorkoutCreateView(LoginRequiredMixin, CreateView):
|
|
model = Workout
|
|
success_url = reverse_lazy('planner:task-list')
|
|
form_class = WorkoutForm
|
|
template_name = 'planner/workout_form.html'
|
|
|
|
def get_initial(self):
|
|
return {**super().get_initial(), 'scheduled_for': timezone.localdate()}
|
|
|
|
def get_template_names(self):
|
|
if self.request.headers.get('HX-Request') == 'true':
|
|
return ['planner/partials/workout_form_panel.html']
|
|
return [self.template_name]
|
|
|
|
def form_valid(self, form):
|
|
form.instance.owner = self.request.user
|
|
response = super().form_valid(form)
|
|
if self.request.headers.get('HX-Request') == 'true':
|
|
return render_workout_section(self.request)
|
|
return redirect('planner:task-list')
|
|
|
|
|
|
class WorkoutUpdateView(OwnedWorkoutQuerysetMixin, UpdateView):
|
|
success_url = reverse_lazy('planner:task-list')
|
|
form_class = WorkoutForm
|
|
template_name = 'planner/workout_form.html'
|
|
|
|
def get_template_names(self):
|
|
if self.request.headers.get('HX-Request') == 'true':
|
|
return ['planner/partials/workout_form_panel.html']
|
|
return [self.template_name]
|
|
|
|
def form_valid(self, form):
|
|
response = super().form_valid(form)
|
|
if self.request.headers.get('HX-Request') == 'true':
|
|
return render_workout_section(self.request)
|
|
return redirect('planner:task-list')
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(['GET'])
|
|
def workout_today(request):
|
|
return render_workout_section(request)
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def toggle_workout_completed(request, pk):
|
|
workout = get_object_or_404(Workout, pk=pk, owner=request.user)
|
|
toggle_workout_completion(workout, timezone.localdate())
|
|
return render_workout_section(request)
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def delete_workout(request, pk):
|
|
workout = get_object_or_404(Workout, pk=pk, owner=request.user)
|
|
workout.delete()
|
|
return render_workout_section(request)
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def toggle_task_completed(request, pk):
|
|
task = get_object_or_404(Task.objects.prefetch_related('subtasks'), pk=pk, owner=request.user)
|
|
task.is_completed = not task.is_completed
|
|
task.save(update_fields=['is_completed', 'updated_at'])
|
|
if request.POST.get('return_to_daily_planner'):
|
|
selected_date = parse_date(request.POST.get('selected_date')) or timezone.localdate()
|
|
try:
|
|
energy_level = int(request.POST.get('energy_level', 3))
|
|
except (TypeError, ValueError):
|
|
energy_level = 3
|
|
destination = (
|
|
f"{reverse('planner:daily-planner')}?selected_date={selected_date.isoformat()}"
|
|
f"&energy_level={energy_level}"
|
|
)
|
|
if request.headers.get('HX-Request') == 'true':
|
|
response = HttpResponse(status=204)
|
|
response['HX-Redirect'] = destination
|
|
return response
|
|
return redirect(destination)
|
|
if request.headers.get('HX-Request') != 'true':
|
|
return redirect('planner:task-list')
|
|
return render(request, 'planner/partials/task_card.html', {'task': task})
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def toggle_task_active(request, pk):
|
|
task = get_object_or_404(Task.objects.prefetch_related('subtasks'), pk=pk, owner=request.user)
|
|
task.is_active = not task.is_active
|
|
task.save(update_fields=['is_active', 'updated_at'])
|
|
return render(request, 'planner/partials/task_card.html', {'task': task})
|
|
|
|
|
|
@login_required
|
|
@require_http_methods(['GET', 'POST'])
|
|
def user_settings(request):
|
|
profile, _ = UserSettings.objects.get_or_create(user=request.user)
|
|
sick_day, _ = SickDaySettings.objects.get_or_create(user=request.user)
|
|
fasting = FastingSettings.objects.filter(user=request.user).first()
|
|
profile_form = UserSettingsForm(instance=profile)
|
|
sick_form = SickDaySettingsForm(instance=sick_day)
|
|
fasting_form = FastingSettingsForm(instance=fasting)
|
|
time_zone_form = TimeZoneSettingsForm(instance=profile)
|
|
|
|
if request.method == 'POST':
|
|
section = request.POST.get('section')
|
|
if section == 'location':
|
|
profile_form = UserSettingsForm(request.POST, instance=profile)
|
|
if profile_form.is_valid():
|
|
profile_form.save()
|
|
messages.success(request, 'Your weather location was saved.')
|
|
return redirect('planner:user-settings')
|
|
elif section == 'sick-day':
|
|
sick_form = SickDaySettingsForm(request.POST, instance=sick_day)
|
|
if sick_form.is_valid():
|
|
sick_form.save()
|
|
messages.success(request, 'Sick Day settings were saved.')
|
|
return redirect('planner:user-settings')
|
|
elif section == 'time-zone':
|
|
time_zone_form = TimeZoneSettingsForm(request.POST, instance=profile)
|
|
if time_zone_form.is_valid():
|
|
time_zone_form.save()
|
|
messages.success(request, 'Your time zone was saved.')
|
|
return redirect('planner:user-settings')
|
|
elif section == 'fasting':
|
|
fasting_form = FastingSettingsForm(request.POST, instance=fasting)
|
|
if fasting_form.is_valid():
|
|
configure_fasting(request.user, **fasting_form.cleaned_data)
|
|
messages.success(request, 'Fasting settings were saved.')
|
|
return redirect('planner:user-settings')
|
|
else:
|
|
return redirect('planner:user-settings')
|
|
|
|
return render(request, 'planner/user_settings.html', {
|
|
'profile_form': profile_form,
|
|
'sick_form': sick_form,
|
|
'fasting_form': fasting_form,
|
|
'time_zone_form': time_zone_form,
|
|
})
|
|
|
|
|
|
@require_http_methods(['GET', 'POST'])
|
|
def register(request):
|
|
if request.user.is_authenticated:
|
|
return redirect('planner:task-list')
|
|
form = RegistrationForm(request.POST or None)
|
|
if request.method == 'POST' and form.is_valid():
|
|
user = form.save()
|
|
user.is_staff = False
|
|
user.is_superuser = False
|
|
user.save(update_fields=['is_staff', 'is_superuser'])
|
|
login(request, user)
|
|
return redirect('planner:task-list')
|
|
return render(request, 'planner/register.html', {'form': form})
|
|
|
|
|
|
@require_POST
|
|
def logout_view(request):
|
|
logout(request)
|
|
return redirect('planner:login')
|