Files
Django_TasksApp/main/planner/views.py
T
2026-09-30 17:25:25 +02:00

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