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_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 bowel 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 daily water goal was 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): 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): 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)) @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')