Files
Django_TasksApp/main/planner/views.py
T

701 lines
28 KiB
Python

import calendar
from datetime import timedelta
from django.contrib import messages
from django.contrib.auth import login, logout
from django.contrib.auth.decorators import login_required
from django.http import Http404, HttpResponse, JsonResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.urls import reverse, reverse_lazy
from django.utils import timezone
from django.utils.dateparse import parse_date
from django.views.decorators.http import require_http_methods, require_POST
from django.contrib.auth.mixins import LoginRequiredMixin
from django.views.generic import CreateView, DeleteView, DetailView, ListView, TemplateView, UpdateView
from .forms import (
DailyPlannerForm, FastingSettingsForm, RegistrationForm, SickDaySettingsForm, SleepCheckInForm, TimeZoneSettingsForm,
NeckHeadacheCheckInForm, TaskForm, UserSettingsForm, WorkoutForm,
)
from .models import FastingPeriod, FastingSettings, NeckHeadacheCheckIn, SickDaySettings, SleepCheckIn, Task, UserSettings, Workout
from .services.checkins import (
ANNUAL_PHYSIOTHERAPY_SESSION_ALLOWANCE, LOW_PAIN_STREAK_THRESHOLD, calculate_check_in_streaks,
)
from .services.fasting import (
configure_fasting, current_fasting_phase, set_fasting_tracking_enabled,
synchronize_fasting_periods,
)
from .services.scheduling import daily_recommendations, duration_budget_for_energy
from .services.workouts import toggle_workout_completion, workouts_for_day
from .timezones import localdate_for_user
from .services.weather import (
WEATHER_ICON_NAMES, WEATHER_LABELS, forecast_for_user_on_date, forecasts_for_user,
)
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 == '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')