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.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, 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, ) 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': 'The wellbeing panel keeps pain and sleep check-ins separate, while its calendar makes 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 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 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: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)) profile, _ = UserSettings.objects.get_or_create(user=self.request.user) context['onboarding_tour'] = onboarding_context(profile) 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_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) 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 == '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, 'sick_form': sick_form, 'fasting_form': fasting_form, 'time_zone_form': time_zone_form, 'onboarding_enabled': profile.onboarding_enabled, }) @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')