Files
Django_TasksApp/main/planner/views.py
T
2026-10-11 20:46:55 +02:00

926 lines
39 KiB
Python

import calendar
from hashlib import sha256
from datetime import timedelta
from django.conf import settings
from django.contrib import messages
from django.contrib.auth import login, logout
from django.contrib.auth.decorators import login_required
from django.core.exceptions import ValidationError
from django.core.validators import URLValidator
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.http import url_has_allowed_host_and_scheme
from django.utils.dateparse import parse_date
from django.views.decorators.http import require_GET, 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, FoodGoalForm, RegistrationForm, SickDaySettingsForm, SleepCheckInForm, TimeZoneSettingsForm,
BowelHealthCheckInForm, NeckHeadacheCheckInForm, TaskForm, UserSettingsForm, WorkoutForm, HydrationGoalForm, WaterIntakeForm, NtfySettingsForm,
)
from .models import BowelHealthCheckIn, FastingPeriod, FastingSettings, NeckHeadacheCheckIn, SickDaySettings, SleepCheckIn, Task, ToothBrushing, UserSettings, Workout, WaterIntakeEntry
from .services.hydration import hydration_context
from .services.gitea_activity import activity_context
from .services.notifications import NotificationError, send_ntfy_notification
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,
)
ONBOARDING_STEPS = (
{
'target': 'tasks',
'title': 'Start with one clear task',
'copy': 'Add a task here, then use Mark complete when it is done. Subtasks appear after their parent task is completed.',
},
{
'target': 'daily-planner',
'title': 'Use the Daily planner for a realistic next step',
'copy': 'Choose a day and energy level to see a short, prioritised plan for what fits today.',
},
{
'target': 'workouts',
'title': 'Track movement without turning it into a task',
'copy': 'Add workouts here and mark them complete for the day. Their calorie totals stay separate from your task plan.',
},
{
'target': 'wellbeing',
'title': 'Keep a lightweight wellbeing record',
'copy': 'Open Health for pain, sleep, and gut health check-ins, with calendars that make past days easy to revisit.',
},
{
'target': 'fasting',
'title': 'Optional routines stay separate from tasks',
'copy': 'Fasting runs as an optional daily routine with clear start and end windows, separate from your tasks and wellbeing records.',
},
{
'target': 'settings',
'title': 'Make Tasknest yours',
'copy': 'Settings holds your time zone, weather location, recovery options, and this tour if you want to run it again.',
},
)
def onboarding_context(profile):
if not profile.onboarding_enabled:
return None
step = min(profile.onboarding_step, len(ONBOARDING_STEPS) - 1)
return {
**ONBOARDING_STEPS[step],
'number': step + 1,
'total': len(ONBOARDING_STEPS),
'is_last': step == len(ONBOARDING_STEPS) - 1,
}
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 brushing_context(user, today=None):
today = today or localdate_for_user(user)
monday = today - timedelta(days=today.weekday())
records = {record.date: record for record in ToothBrushing.objects.filter(user=user, date__range=(monday, today))}
return {'brushing_days': [{'date': day, 'record': records.get(day)} for day in
(monday + timedelta(days=offset) for offset in range(today.weekday() + 1))]}
def bowel_context(user, selected_date=None, form=None):
today = localdate_for_user(user)
selected_date = selected_date or today
month_start = selected_date.replace(day=1)
first_day = calendar.Calendar(firstweekday=0).monthdatescalendar(selected_date.year, selected_date.month)[0][0]
last_day = calendar.Calendar(firstweekday=0).monthdatescalendar(selected_date.year, selected_date.month)[-1][-1]
records = {entry.check_in_date: entry for entry in BowelHealthCheckIn.objects.filter(user=user, check_in_date__range=(first_day, min(last_day, today)))}
if form is None:
form = BowelHealthCheckInForm(instance=records.get(selected_date), initial={'check_in_date': selected_date}, user=user)
weeks = []
for week in calendar.Calendar(firstweekday=0).monthdatescalendar(selected_date.year, selected_date.month):
cells = []
for day in week:
entry = records.get(day)
periods = []
labels = []
for period, short in (('morning', 'M'), ('afternoon', 'A'), ('evening', 'E')):
score = getattr(entry, f'{period}_severity', None)
periods.append({'short_label': short, 'score': score, 'level': pain_level(score) if score is not None else 'unrecorded'})
labels.append(f'{period.title()}: {score} of 10' if score is not None else f'{period.title()}: not recorded')
cells.append({'date': day, 'periods': periods, 'label': f'{day:%A, %d %B}: ' + '; '.join(labels),
'is_today': day == today, 'is_selected': day == selected_date,
'is_outside_month': day.month != selected_date.month})
weeks.append(cells)
return {'bowel_form': form, 'bowel_selected_date': selected_date, 'bowel_calendar_weeks': weeks,
'bowel_previous_month': month_start - timedelta(days=1),
'bowel_next_month': (month_start + timedelta(days=32)).replace(day=1)}
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:
form = NeckHeadacheCheckInForm(
instance=selected_check_in, initial={"check_in_date": selected_date}, 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)
periods = []
period_labels = []
for period, period_label, short_label in NeckHeadacheCheckIn.PERIODS:
neck = getattr(check_in, f"{period}_neck_pain_severity", None)
headache = getattr(check_in, f"{period}_headache_severity", None)
if neck is not None and headache is not None:
score = max(neck, headache)
level = pain_level(score)
period_labels.append(
f"{period_label}: neck pain {neck} of 10; headache {headache} of 10"
)
else:
score = None
level = "unrecorded"
period_labels.append(f"{period_label}: pain not recorded")
periods.append({"short_label": short_label, "score": score, "level": level})
label = f"{day:%A, %d %B}: " + "; ".join(period_labels)
if check_in is not None and 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,
"periods": periods,
"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 duration_as_hours_and_minutes(minutes):
hours, remaining_minutes = divmod(minutes, 60)
parts = []
if hours:
parts.append(f'{hours} hour{"s" if hours != 1 else ""}')
if remaining_minutes:
parts.append(f'{remaining_minutes} min')
return ' '.join(parts) or '0 min'
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:
phase = current_fasting_phase(fasting_settings)
fasting_duration = fasting_settings.fasting_duration_minutes
if phase.is_fasting:
current_window = ('Fasting window', phase.cycle_start, phase.cycle_end)
next_window = ('Next eating window', phase.cycle_end, phase.scheduled_start + timedelta(days=1))
else:
current_window = ('Eating window', phase.cycle_start, phase.cycle_end)
next_window = ('Next fasting window', phase.cycle_end, phase.cycle_end + timedelta(minutes=fasting_duration))
context.update(
fasting_phase=phase,
fasting_duration_display=duration_as_hours_and_minutes(fasting_duration),
eating_duration_display=duration_as_hours_and_minutes((24 * 60) - fasting_duration),
current_window_label=current_window[0],
current_window_start=current_window[1],
current_window_end=current_window[2],
next_window_label=next_window[0],
next_window_start=next_window[1],
next_window_end=next_window[2],
)
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:health') + '?check_in_date=' + check_in.check_in_date.isoformat() + '#neck-headache-checkin'
)
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:health') + '?check_in_date=' + check_in.wake_up_date.isoformat() + '&wellbeing_tab=sleep#neck-headache-checkin'
)
return render_check_in_panel(request, selected_date, sleep_form=form, active_tab='sleep')
@login_required
@require_POST
def toggle_tooth_brushing(request):
day = parse_date(request.POST.get('date', ''))
period = request.POST.get('period')
today = localdate_for_user(request.user)
if day is None or day > today or day < today - timedelta(days=today.weekday()) or period not in ('morning', 'evening'):
return HttpResponse('Invalid brushing day or period.', status=400)
record, _ = ToothBrushing.objects.get_or_create(user=request.user, date=day)
setattr(record, period, not getattr(record, period))
record.save(update_fields=[period])
return render(request, 'planner/partials/tooth_brushing_control.html',
{'brushing_day': day, 'brushing_period': period, 'brushing_done': getattr(record, period)})
@login_required
@require_http_methods(['GET'])
def bowel_health_panel(request):
selected_date = selected_check_in_date(request.GET.get('date'), request.user)
if selected_date is None:
return HttpResponse('Invalid date.', status=400)
return render(request, 'planner/partials/bowel_health_checkin.html', bowel_context(request.user, selected_date))
@login_required
@require_POST
def save_bowel_health_checkin(request):
selected_date = parse_date(request.POST.get('check_in_date', ''))
existing = BowelHealthCheckIn.objects.filter(user=request.user, check_in_date=selected_date).first() if selected_date else None
form = BowelHealthCheckInForm(request.POST, instance=existing, user=request.user)
if form.is_valid():
entry = form.save(commit=False)
entry.user = request.user
entry.save()
if request.headers.get('HX-Request') == 'true':
return render(request, 'planner/partials/bowel_health_checkin.html', bowel_context(request.user, entry.check_in_date))
return redirect(reverse('planner:health') + '?bowel_date=' + entry.check_in_date.isoformat() + '#bowel-health-checkin')
return render(request, 'planner/partials/bowel_health_checkin.html', bowel_context(request.user, selected_date, form))
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')
def task_filter_status(value):
return value if value in {'active', 'all', 'past'} else 'active'
def tasks_for_filter(user, status):
tasks = Task.objects.filter(owner=user, parent_task__isnull=True).prefetch_related('subtasks')
if status == 'active':
return tasks.filter(is_active=True, is_completed=False)
if status == 'past':
return tasks.filter(is_completed=True).order_by('-scheduled_for', 'title')
return tasks
def render_task_list(request, status):
tasks = add_predicted_weather(request.user, tasks_for_filter(request.user, status))
return render(request, 'planner/partials/task_list_content.html', {'tasks': tasks, 'current_filter': status})
class TaskListView(LoginRequiredMixin, ListView):
model = Task
context_object_name = 'tasks'
template_name = 'planner/task_list.html'
def task_filter(self):
return task_filter_status(self.request.GET.get('status', 'active'))
def get_queryset(self):
return tasks_for_filter(self.request.user, self.task_filter())
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.task_filter()
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(brushing_context(self.request.user))
context.update(hydration_context(self.request.user))
context['gitea_activity_enabled'] = bool(settings.GITEA_USERNAME)
profile, _ = UserSettings.objects.get_or_create(user=self.request.user)
context['onboarding_tour'] = onboarding_context(profile)
return context
@login_required
@require_http_methods(['GET'])
def gitea_activity(request):
return render(request, 'planner/partials/gitea_activity.html', activity_context())
class HealthView(LoginRequiredMixin, TemplateView):
template_name = 'planner/health.html'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
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'),
))
context.update(bowel_context(
self.request.user, selected_check_in_date(self.request.GET.get('bowel_date'), self.request.user),
))
context.update(fasting_widget_context(self.request.user))
context.update(hydration_context(self.request.user))
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':
return render_task_list(self.request, 'active')
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)
current_filter = task_filter_status(request.POST.get('status'))
if request.headers.get('HX-Request') != 'true':
return redirect(reverse('planner:task-list') + '?status=' + current_filter)
return render_task_list(request, current_filter)
@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'])
current_filter = task_filter_status(request.POST.get('status'))
if request.headers.get('HX-Request') != 'true':
return redirect(reverse('planner:task-list') + '?status=' + current_filter)
return render_task_list(request, current_filter)
@login_required
@require_POST
def advance_onboarding(request):
profile, _ = UserSettings.objects.get_or_create(user=request.user)
action = request.POST.get('action')
if action == 'skip':
profile.onboarding_enabled = False
elif action == 'next':
if profile.onboarding_step >= len(ONBOARDING_STEPS) - 1:
profile.onboarding_enabled = False
else:
profile.onboarding_step += 1
profile.onboarding_enabled = True
profile.save(update_fields=['onboarding_enabled', 'onboarding_step', 'updated_at'])
return redirect('planner:task-list')
@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)
hydration_goal_form = HydrationGoalForm(instance=profile)
food_goal_form = FoodGoalForm(instance=profile)
sick_form = SickDaySettingsForm(instance=sick_day)
fasting_form = FastingSettingsForm(instance=fasting)
time_zone_form = TimeZoneSettingsForm(instance=profile)
ntfy_form = NtfySettingsForm(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 == 'hydration':
hydration_goal_form = HydrationGoalForm(request.POST, instance=profile)
if hydration_goal_form.is_valid():
hydration_goal_form.save()
messages.success(request, 'Your hydration settings were saved.')
return redirect('planner:user-settings')
elif section == 'food':
food_goal_form = FoodGoalForm(request.POST, instance=profile)
if food_goal_form.is_valid():
food_goal_form.save()
messages.success(request, 'Your food goals were saved.')
return redirect('planner:user-settings')
elif section == 'ntfy':
old_url = profile.ntfy_url
ntfy_form = NtfySettingsForm(request.POST, instance=profile)
if ntfy_form.is_valid():
url = ntfy_form.cleaned_data['ntfy_url']
tested = bool(url) and request.session.get(f'ntfy_tested:{request.user.pk}') == sha256(url.encode()).hexdigest()
previously_tested = url == old_url and profile.ntfy_last_tested_at is not None
if ntfy_form.cleaned_data['ntfy_enabled'] and not (tested or previously_tested):
ntfy_form.add_error('ntfy_url', 'Test this URL successfully before enabling notifications.')
else:
profile = ntfy_form.save(commit=False)
if not url:
profile.ntfy_enabled = False
profile.ntfy_last_tested_at = None
elif tested:
profile.ntfy_last_tested_at = timezone.now()
elif url != old_url:
profile.ntfy_last_tested_at = None
profile.save()
request.session.pop(f'ntfy_tested:{request.user.pk}', None)
messages.success(request, 'Notification settings were 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 == 'appearance':
appearance = request.POST.get('appearance')
if appearance in UserSettings.Appearance.values:
profile.appearance = appearance
profile.save(update_fields=['appearance', 'updated_at'])
messages.success(request, f"{appearance.capitalize()} mode is on.")
next_url = request.POST.get('next', '')
if url_has_allowed_host_and_scheme(
next_url, allowed_hosts={request.get_host()}, require_https=request.is_secure()
):
return redirect(next_url)
return redirect('planner:user-settings')
elif section == 'onboarding':
action = request.POST.get('action')
if action == 'restart':
profile.onboarding_enabled = True
profile.onboarding_step = 0
profile.save(update_fields=['onboarding_enabled', 'onboarding_step', 'updated_at'])
return redirect('planner:task-list')
if action == 'disable':
profile.onboarding_enabled = False
profile.save(update_fields=['onboarding_enabled', 'updated_at'])
messages.success(request, 'First-run help is off.')
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,
'hydration_goal_form': hydration_goal_form,
'food_goal_form': food_goal_form,
'sick_form': sick_form,
'fasting_form': fasting_form,
'time_zone_form': time_zone_form,
'ntfy_form': ntfy_form,
'onboarding_enabled': profile.onboarding_enabled,
})
@login_required
@require_POST
def test_ntfy(request):
url = request.POST.get('ntfy_url', '').strip()
try:
URLValidator(schemes=['http', 'https'])(url)
except ValidationError:
return render(request, 'planner/partials/ntfy_test_result.html', {'error': 'Enter a valid HTTP or HTTPS topic URL.'}, status=400)
try:
send_ntfy_notification(url, 'Tasknest', 'Test notification sent successfully.')
except NotificationError as error:
return render(request, 'planner/partials/ntfy_test_result.html', {'error': str(error)}, status=502)
request.session[f'ntfy_tested:{request.user.pk}'] = sha256(url.encode()).hexdigest()
return render(request, 'planner/partials/ntfy_test_result.html', {'success': True})
@login_required
@require_POST
def hydration_add(request):
if not UserSettings.objects.get_or_create(user=request.user)[0].allow_manual_hydration_adjustments:
return HttpResponse(status=403)
form = WaterIntakeForm(request.POST)
if form.is_valid():
WaterIntakeEntry.objects.create(user=request.user, amount_ml=form.cleaned_data['amount_ml'])
context = hydration_context(request.user)
context['hydration_error'] = form.errors.get('amount_ml') if not form.is_valid() else None
return render(request, 'planner/partials/hydration_widget.html', context)
@login_required
@require_POST
def hydration_undo(request):
if not UserSettings.objects.get_or_create(user=request.user)[0].allow_manual_hydration_adjustments:
return HttpResponse(status=403)
context = hydration_context(request.user)
if context['hydration_last']:
context['hydration_last'].delete()
return render(request, 'planner/partials/hydration_widget.html', hydration_context(request.user))
@login_required
@require_GET
def hydration_panel(request):
return render(request, 'planner/partials/hydration_widget.html', hydration_context(request.user))
@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')