Add task occurrence scheduling and card completion workflow

This commit is contained in:
Joren de Graaf
2026-10-28 21:05:32 +01:00
parent 22d9757ddd
commit 2f84a9f359
15 changed files with 526 additions and 9 deletions
+8
View File
@@ -28,3 +28,11 @@ When I give you a card to work on, you should:
1. Look in the TasksNest project
2. Move the card to in-progress and add any pertinent findings at the end to the progress notes. This also applies to passes/phases that have a defined downtime for me to check and push things to git.
3. When you're done with the card you can move it to complete.
## Project card completion and Git workflow
After completing a project card, run relevant tests and verify the changes. Summarise the changes and test results for the user.
Always request the user's explicit permission before executing any Git commit. Never commit automatically or bypass approval. Once approved, create a descriptive commit containing only the intended changes for that card. Record the commit hash and test results in the completed project card.
Never push or deploy automatically. Push or deploy only when the user explicitly requests it. This rule takes precedence over deployment instructions elsewhere in this file.
+14
View File
@@ -114,6 +114,20 @@ h2 { font-family: Fraunces, Georgia, serif; letter-spacing: -.03em; }
.form-layout { display: grid; grid-template-columns: minmax(250px, .7fr) minmax(0, 1.3fr); gap: clamp(32px, 7vw, 100px); align-items: start; }.form-layout__intro { padding-top: 25px; }.form-layout__intro h1 { font-size: clamp(2.4rem, 4vw, 3.5rem); }.form-layout__intro p:last-child { color: $muted; font-size: 1.05rem; }.task-form { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 20px; padding: 30px; }.field { min-width: 0; }.field--title, .field--description, .field--parent_task, .form-actions { grid-column: 1 / -1; }.field label:not(.checkbox-field) { display: block; margin-bottom: 7px; color: #444b4b; font-size: .85rem; font-weight: 700; }.field input:not([type='checkbox']), .field select, .field textarea { width: 100%; padding: 10px 11px; border: 1px solid #cfd4cb; border-radius: 9px; color: $ink; background: white; outline: none; transition: border .15s, box-shadow .15s; &:focus { border-color: $forest; box-shadow: 0 0 0 3px rgba($forest, .12); } }.field textarea { resize: vertical; }.checkbox-field { display: inline-flex; align-items: center; gap: 8px; min-height: 42px; color: #444b4b; font-size: .9rem; font-weight: 600; }.checkbox-field input { width: 17px; height: 17px; accent-color: $forest; }.field small { display: block; margin-top: 4px; color: $muted; }.field--error input, .field--error select, .field--error textarea { border-color: $coral; }.field-error, .form-errors { margin: 5px 0 0; color: #aa382d; font-size: .84rem; }.form-errors { grid-column: 1 / -1; padding: 11px; border-radius: 8px; background: #fff0ed; }.form-actions { display: flex; align-items: center; gap: 18px; margin-top: 4px; }.confirmation-card { max-width: 660px; padding: 46px; }.confirmation-card h1 { font-size: clamp(2.2rem, 4vw, 3.4rem); }.confirmation-card > p:not(.eyebrow) { max-width: 500px; color: $muted; font-size: 1.05rem; }
.visually-hidden { position: absolute; width: 1px; height: 1px; padding: 0; margin: -1px; overflow: hidden; clip: rect(0, 0, 0, 0); white-space: nowrap; border: 0; }
.occurrence-list { max-width: 760px; }
.occurrence-list li { display: grid; grid-template-columns: minmax(0, 1fr) auto; gap: 12px 18px; align-items: start; padding: 19px 4px; }
.occurrence-list__summary { display: grid; gap: 3px; }
.occurrence-list__summary strong { font-size: .96rem; }
.occurrence-list__complete { justify-self: end; }
.occurrence-list__form { grid-column: 1 / -1; display: flex; flex-wrap: wrap; align-items: center; gap: 8px 12px; }
.occurrence-list__form label { font-size: .82rem; font-weight: 700; }
.occurrence-list__form input, .occurrence-list__form select { min-height: 38px; padding: 7px 9px; border: 1px solid #cfd4cb; border-radius: 8px; color: $ink; background: white; }
.occurrence-list__form input[type='time'] { width: 130px; }
.occurrence-list__form input[type='date'] { width: 160px; }
.occurrence-list__form .button { min-height: 38px; }
body[data-theme='dark'] .occurrence-list__form input, body[data-theme='dark'] .occurrence-list__form select { color: #f4f5f0; background: #202923; border-color: #59675d; }
@media (max-width: 560px) { .occurrence-list li { grid-template-columns: 1fr; }.occurrence-list__complete { justify-self: start; }.occurrence-list__form { grid-column: 1; }.occurrence-list__form--state label[for^='occurrence-snooze'] { flex-basis: 100%; } }
@media (max-width: 820px) { .home-layout { grid-template-columns: 1fr; }.homepage-sidebar { position: static; }.planner-hero { grid-template-columns: 1fr; align-items: start; }.planner-controls { justify-content: start; }.task-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }.form-layout { grid-template-columns: 1fr; }.form-layout__intro { padding-top: 0; }.detail-card__header, .detail-card__body { padding: 30px; }.detail-card__header { display: block; }.detail-card__actions { margin-top: 24px; }.detail-card__body { grid-template-columns: 1fr; gap: 30px; } }
@media (max-width: 560px) { .planner-controls { display: grid; grid-template-columns: 1fr; }.planner-controls input, .planner-controls select { width: 100%; }.recommendations-panel__header { display: block; padding: 20px; }.budget-note { margin-top: 10px; }.recommendation-list { padding: 8px 20px 20px; }.recommendation-card { grid-template-columns: 1fr; }.recommendation-card > .text-link { justify-self: start; }.site-header__inner, .page-content { padding-left: 18px; padding-right: 18px; }.site-header__inner { min-height: 62px; }.primary-nav { gap: 12px; }.primary-nav > a:not(.button) { display: none; }.page-content { padding-top: 40px; }.hero { display: block; margin-bottom: 30px; }.hero .button { margin-top: 21px; }.task-filters { flex-wrap: wrap; padding: 17px; }.task-filters > div { flex: 1; }.task-filters__actions { width: 100%; margin-left: 0; }.task-filters select { width: 100%; }.task-grid { grid-template-columns: 1fr; padding: 15px; }.task-form { grid-template-columns: 1fr; padding: 22px; }.field--title, .field--description, .field--parent_task, .form-actions { grid-column: auto; }.detail-card__header, .detail-card__body, .confirmation-card, .inline-form-panel { padding: 25px; }.detail-card__actions { align-items: center; }.subtasks-list li { padding-left: 0; padding-right: 0; } }
+29 -1
View File
@@ -7,6 +7,8 @@ from zoneinfo import available_timezones
from .models import BowelHealthCheckIn, FastingSettings, NeckHeadacheCheckIn, SickDaySettings, SleepCheckIn, Task, UserSettings, Workout
from .timezones import localdate_for_user
from .services.occurrences import validate_local_time
from django.core.exceptions import ValidationError
class TaskForm(forms.ModelForm):
@@ -14,17 +16,23 @@ class TaskForm(forms.ModelForm):
model = Task
fields = (
'title', 'description', 'estimated_duration_minutes', 'priority', 'category',
'scheduled_for', 'is_recurring', 'recurrence_interval', 'recurrence_unit',
'scheduled_for', 'scheduled_time', 'time_zone', 'is_recurring', 'recurrence_interval', 'recurrence_unit',
'defer_days', 'is_active', 'is_outdoor', 'weather_profile', 'required_on_sick_day', 'parent_task',
)
widgets = {
'description': forms.Textarea(attrs={'rows': 5}),
'scheduled_for': forms.DateInput(attrs={'type': 'date'}),
'scheduled_time': forms.TimeInput(attrs={'type': 'time'}),
}
def __init__(self, *args, owner=None, **kwargs):
super().__init__(*args, **kwargs)
self.owner = owner
self.fields['time_zone'].required = False
if owner and not self.instance.pk:
settings = UserSettings.objects.filter(user=owner).only('time_zone').first()
self.fields['time_zone'].initial = settings.time_zone if settings else 'Europe/Amsterdam'
self.fields['time_zone'].widget = forms.Select(choices=TIME_ZONE_CHOICES)
parents = Task.objects.filter(parent_task__isnull=True)
if owner is not None:
parents = parents.filter(owner=owner)
@@ -56,6 +64,26 @@ class TaskForm(forms.ModelForm):
return normalized
return category
def clean_time_zone(self):
name = self.cleaned_data.get('time_zone')
if name:
return name
if self.instance.pk:
return self.instance.time_zone
settings = UserSettings.objects.filter(user=self.owner).only('time_zone').first() if self.owner else None
return settings.time_zone if settings else 'Europe/Amsterdam'
def clean(self):
data = super().clean()
if data.get('scheduled_for') and data.get('time_zone'):
try:
validate_local_time(data['scheduled_for'], data.get('scheduled_time'), data['time_zone'])
except ValidationError as exc:
self.add_error('scheduled_time', exc)
if data.get('is_recurring') and not data.get('recurrence_unit'):
self.add_error('recurrence_unit', 'Choose a repeat unit.')
return data
class DailyPlannerForm(forms.Form):
selected_date = forms.DateField(
@@ -0,0 +1,77 @@
# Generated by Django 6.1.1 on 2026-10-28 19:39
import django.db.models.deletion
from django.db import migrations, models
def preserve_existing_completion(apps, schema_editor):
Task = apps.get_model('planner', 'Task')
TaskOccurrence = apps.get_model('planner', 'TaskOccurrence')
UserSettings = apps.get_model('planner', 'UserSettings')
zones = dict(UserSettings.objects.values_list('user_id', 'time_zone'))
for task in Task.objects.iterator():
zone = zones.get(task.owner_id) or 'Europe/Amsterdam'
Task.objects.filter(pk=task.pk).update(time_zone=zone)
if task.is_completed:
TaskOccurrence.objects.create(
task_id=task.pk, scheduled_date=task.scheduled_for,
time_zone=zone, status='completed',
)
if task.is_recurring:
Task.objects.filter(pk=task.pk).update(is_completed=False)
class Migration(migrations.Migration):
dependencies = [
('planner', '0022_usersettings_is_demo'),
]
operations = [
migrations.AddField(
model_name='task',
name='scheduled_time',
field=models.TimeField(blank=True, null=True),
),
migrations.AddField(
model_name='task',
name='time_zone',
field=models.CharField(default='Europe/Amsterdam', max_length=64),
),
migrations.CreateModel(
name='TaskOccurrence',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('scheduled_date', models.DateField()),
('scheduled_time', models.TimeField(blank=True, null=True)),
('time_zone', models.CharField(default='Europe/Amsterdam', max_length=64)),
('is_time_override', models.BooleanField(default=False)),
('status', models.CharField(choices=[('pending', 'Pending'), ('completed', 'Completed'), ('skipped', 'Skipped'), ('snoozed', 'Snoozed')], default='pending', max_length=10)),
('snoozed_until', models.DateField(blank=True, null=True)),
('created_at', models.DateTimeField(auto_now_add=True)),
('updated_at', models.DateTimeField(auto_now=True)),
('task', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='occurrences', to='planner.task')),
],
options={
'ordering': ('scheduled_date',),
},
),
migrations.CreateModel(
name='TaskOccurrenceEvent',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('from_status', models.CharField(choices=[('pending', 'Pending'), ('completed', 'Completed'), ('skipped', 'Skipped'), ('snoozed', 'Snoozed')], max_length=10)),
('to_status', models.CharField(choices=[('pending', 'Pending'), ('completed', 'Completed'), ('skipped', 'Skipped'), ('snoozed', 'Snoozed')], max_length=10)),
('changed_at', models.DateTimeField(auto_now_add=True)),
('occurrence', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='events', to='planner.taskoccurrence')),
],
options={
'ordering': ('changed_at', 'pk'),
},
),
migrations.AddConstraint(
model_name='taskoccurrence',
constraint=models.UniqueConstraint(fields=('task', 'scheduled_date'), name='unique_task_occurrence_date'),
),
migrations.RunPython(preserve_existing_completion, migrations.RunPython.noop),
]
@@ -0,0 +1,23 @@
# Generated by Django 6.1.1 on 2026-10-28 19:54
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('planner', '0023_task_scheduled_time_task_time_zone_taskoccurrence_and_more'),
]
operations = [
migrations.AddField(
model_name='taskoccurrenceevent',
name='from_snoozed_until',
field=models.DateField(blank=True, null=True),
),
migrations.AddField(
model_name='taskoccurrenceevent',
name='to_snoozed_until',
field=models.DateField(blank=True, null=True),
),
]
+39
View File
@@ -46,6 +46,8 @@ class Task(models.Model):
is_active = models.BooleanField(default=True)
is_completed = models.BooleanField(default=False)
scheduled_for = models.DateField()
scheduled_time = models.TimeField(blank=True, null=True)
time_zone = models.CharField(max_length=64, default='Europe/Amsterdam')
recurrence_interval = models.PositiveIntegerField(default=1, blank=True, null=True)
recurrence_unit = models.CharField(max_length=5, choices=RecurrenceUnit.choices, blank=True)
created_at = models.DateTimeField(auto_now_add=True)
@@ -95,6 +97,43 @@ class Task(models.Model):
ancestor = ancestor.parent_task
class TaskOccurrence(models.Model):
class Status(models.TextChoices):
PENDING = 'pending', 'Pending'
COMPLETED = 'completed', 'Completed'
SKIPPED = 'skipped', 'Skipped'
SNOOZED = 'snoozed', 'Snoozed'
task = models.ForeignKey(Task, on_delete=models.CASCADE, related_name='occurrences')
scheduled_date = models.DateField()
scheduled_time = models.TimeField(blank=True, null=True)
time_zone = models.CharField(max_length=64, default='Europe/Amsterdam')
is_time_override = models.BooleanField(default=False)
status = models.CharField(max_length=10, choices=Status.choices, default=Status.PENDING)
snoozed_until = models.DateField(blank=True, null=True)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
class Meta:
ordering = ('scheduled_date',)
constraints = [models.UniqueConstraint(fields=('task', 'scheduled_date'), name='unique_task_occurrence_date')]
def __str__(self):
return f'{self.task} on {self.scheduled_date}'
class TaskOccurrenceEvent(models.Model):
occurrence = models.ForeignKey(TaskOccurrence, on_delete=models.CASCADE, related_name='events')
from_status = models.CharField(max_length=10, choices=TaskOccurrence.Status.choices)
to_status = models.CharField(max_length=10, choices=TaskOccurrence.Status.choices)
from_snoozed_until = models.DateField(blank=True, null=True)
to_snoozed_until = models.DateField(blank=True, null=True)
changed_at = models.DateTimeField(auto_now_add=True)
class Meta:
ordering = ('changed_at', 'pk')
class UserSettings(models.Model):
"""Private, per-user preferences that do not belong on Django's User model."""
+107
View File
@@ -0,0 +1,107 @@
"""Shared, user-scoped task occurrence operations."""
from datetime import datetime, timedelta
from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
from django.core.exceptions import ValidationError
from django.db import transaction
from planner.models import Task, TaskOccurrence, TaskOccurrenceEvent
from planner.services.scheduling import is_task_scheduled_on_date
def validate_local_time(day, clock, zone_name):
if clock is None:
return
try:
zone = ZoneInfo(zone_name)
except ZoneInfoNotFoundError as exc:
raise ValidationError('Choose a valid IANA time zone.') from exc
local = datetime.combine(day, clock)
# Round trips detect clock times lost in a spring DST transition.
aware = local.replace(tzinfo=zone, fold=0)
round_trip = aware.astimezone(ZoneInfo('UTC')).astimezone(zone).replace(tzinfo=None)
if round_trip != local:
raise ValidationError('This local time does not exist on the selected date.')
# Ambiguous autumn times consistently use the first occurrence (fold=0).
def occurrence_for_date(task, day):
if not is_task_scheduled_on_date(task, day):
raise ValidationError('This date is not part of the task schedule.')
clock = task.scheduled_time
if task.is_recurring and clock is not None:
# Spring gaps move only this occurrence to the first valid wall time.
for _ in range(24 * 60):
try:
validate_local_time(day, clock, task.time_zone)
break
except ValidationError as exc:
if 'does not exist' not in str(exc):
raise
clock = (datetime.combine(day, clock) + timedelta(minutes=1)).time()
else:
raise ValidationError('No valid local time exists on this date.')
else:
validate_local_time(day, clock, task.time_zone)
occurrence, _ = TaskOccurrence.objects.get_or_create(
task=task, scheduled_date=day,
defaults={'scheduled_time': clock, 'time_zone': task.time_zone},
)
if occurrence.status == TaskOccurrence.Status.PENDING and not occurrence.is_time_override and (
occurrence.scheduled_time != clock or occurrence.time_zone != task.time_zone
):
occurrence.scheduled_time = clock
occurrence.time_zone = task.time_zone
occurrence.save(update_fields=['scheduled_time', 'time_zone', 'updated_at'])
return occurrence
def occurrence_for_user(user, task_id, day):
task = Task.objects.get(pk=task_id, owner=user)
return occurrence_for_date(task, day)
@transaction.atomic
def override_occurrence_time(user, task_id, day, clock):
task = Task.objects.select_for_update().get(pk=task_id, owner=user)
validate_local_time(day, clock, task.time_zone)
occurrence = occurrence_for_date(task, day)
occurrence.scheduled_time = clock
occurrence.is_time_override = True
occurrence.save(update_fields=['scheduled_time', 'is_time_override', 'updated_at'])
return occurrence
@transaction.atomic
def set_occurrence_status(user, task_id, day, status, *, snoozed_until=None):
if status not in TaskOccurrence.Status.values:
raise ValidationError('Invalid occurrence status.')
if status == TaskOccurrence.Status.SNOOZED and (snoozed_until is None or snoozed_until <= day):
raise ValidationError('Choose a snooze date after the scheduled date.')
task = Task.objects.select_for_update().get(pk=task_id, owner=user)
occurrence = occurrence_for_date(task, day)
previous = occurrence.status
previous_snooze = occurrence.snoozed_until
if previous != status or occurrence.snoozed_until != snoozed_until:
occurrence.status = status
occurrence.snoozed_until = snoozed_until if status == TaskOccurrence.Status.SNOOZED else None
occurrence.save(update_fields=['status', 'snoozed_until', 'updated_at'])
TaskOccurrenceEvent.objects.create(
occurrence=occurrence, from_status=previous, to_status=status,
from_snoozed_until=previous_snooze, to_snoozed_until=occurrence.snoozed_until,
)
if not task.is_recurring and task.is_completed != (status == TaskOccurrence.Status.COMPLETED):
task.is_completed = status == TaskOccurrence.Status.COMPLETED
task.save(update_fields=['is_completed', 'updated_at'])
return occurrence
def upcoming_occurrences(task, start, count=8, horizon_days=3660):
results = []
day = max(start, task.scheduled_for)
end = day + timedelta(days=horizon_days)
while day <= end and len(results) < count:
if is_task_scheduled_on_date(task, day):
results.append(occurrence_for_date(task, day))
day += timedelta(days=1)
return results
+12 -2
View File
@@ -5,7 +5,7 @@ from dataclasses import dataclass
from datetime import date, timedelta
from typing import TYPE_CHECKING, Iterable
from planner.models import Task, TaskWeatherShift
from planner.models import Task, TaskOccurrence, TaskWeatherShift
if TYPE_CHECKING:
from planner.models import SickDaySettings
@@ -62,6 +62,12 @@ def is_task_eligible(task: Task, selected_date: date) -> bool:
return False
if selected_date == task.deferred_until:
return True
if task.occurrences.filter(status=TaskOccurrence.Status.SNOOZED, snoozed_until=selected_date).exists():
return True
if task.occurrences.filter(scheduled_date=selected_date, status__in=(
TaskOccurrence.Status.COMPLETED, TaskOccurrence.Status.SKIPPED, TaskOccurrence.Status.SNOOZED,
)).exists():
return False
return is_task_scheduled_on_date(task, selected_date)
@@ -156,14 +162,18 @@ def recommend_tasks(top_level_tasks: Iterable[Task], selected_date: date, energy
candidates = []
for parent in top_level_tasks:
if parent.is_completed:
occurrence = parent.occurrences.filter(scheduled_date=selected_date).first() if parent.is_recurring else None
completed_today = occurrence and occurrence.status == TaskOccurrence.Status.COMPLETED
if parent.is_completed or completed_today:
candidates.extend(
subtask for subtask in parent.subtasks.all()
if is_weather_eligible(subtask, selected_date, user)
and not subtask.occurrences.filter(scheduled_date=selected_date, status=TaskOccurrence.Status.COMPLETED).exists()
and not is_sick_day_suppressed(subtask, sick_day_settings, selected_date)
)
elif (
is_weather_eligible(parent, selected_date, user)
and not completed_today
and not is_sick_day_suppressed(parent, sick_day_settings, selected_date)
):
candidates.append(parent)
@@ -47,6 +47,7 @@
Duration flexible
{% endif %}
{% if recommendation.task.is_recurring %} · Recurring{% endif %}
{% if recommendation.task.scheduled_time %} · {{ recommendation.task.scheduled_time|time:'H:i' }} {{ recommendation.task.time_zone }}{% endif %}
{% if not recommendation.task.is_active %} · Paused{% endif %}
{% if recommendation.task.weather_profile != 'none' %} · {{ recommendation.task.get_weather_profile_display }}{% endif %}
{% if recommendation.task.weather_shifted_from %} · Moved from {{ recommendation.task.weather_shifted_from|date:'l' }} — {{ recommendation.task.weather_shift_reason }}{% endif %}
@@ -1,7 +1,7 @@
<article class="task-card{% if not task.is_active %} task-card--inactive{% endif %}{% if task.is_completed %} task-card--completed{% endif %}" id="task-{{ task.pk }}">
<div class="task-card__topline">
<span class="priority priority--{{ task.priority }}">{{ task.get_priority_display }}</span>
<time datetime="{{ task.scheduled_for|date:'Y-m-d' }}">{{ task.scheduled_for|date:"D, j M" }}</time>
<time datetime="{{ task.scheduled_for|date:'Y-m-d' }}">{{ task.scheduled_for|date:"D, j M" }}{% if task.scheduled_time %} at {{ task.scheduled_time|time:'H:i' }}{% endif %}</time>
</div>
<h2><a href="{% url 'planner:task-detail' task.pk %}">{{ task.title }}</a></h2>
{% if task.description %}<p class="task-card__description">{{ task.description|truncatewords:20 }}</p>{% endif %}
@@ -18,6 +18,9 @@
<p class="subtask-count"><span aria-hidden="true">↳</span> {{ task.subtasks.count }} subtask{{ task.subtasks.count|pluralize }}{% if task.is_completed %} unlocked{% else %} — complete this task to unlock{% endif %}</p>
{% endif %}
<footer class="task-card__footer">
{% if task.is_recurring %}
<a class="button button--compact" href="{% url 'planner:task-detail' task.pk %}">View occurrences</a>
{% else %}
<form method="post" action="{% url 'planner:task-toggle-completed' task.pk %}" hx-post="{% url 'planner:task-toggle-completed' task.pk %}" hx-target="#task-list" hx-swap="innerHTML">
{% csrf_token %}
<input type="hidden" name="status" value="{{ current_filter|default:'active' }}">
@@ -26,6 +29,7 @@
{% if task.is_completed %}Completed — reopen{% else %}Mark complete{% endif %}
</button>
</form>
{% endif %}
<form method="post" action="{% url 'planner:task-toggle-active' task.pk %}" hx-post="{% url 'planner:task-toggle-active' task.pk %}" hx-target="#task-list" hx-swap="innerHTML">
{% csrf_token %}
<input type="hidden" name="status" value="{{ current_filter|default:'active' }}">
@@ -9,7 +9,7 @@
<div>
<p class="eyebrow">{{ task.get_priority_display }} priority{% if task.category %} · {{ task.category }}{% endif %}</p>
<h1>{{ task.title }}</h1>
<p class="detail-card__date">Scheduled for <time datetime="{{ task.scheduled_for|date:'Y-m-d' }}">{{ task.scheduled_for|date:"l, j F Y" }}</time></p>
<p class="detail-card__date">Scheduled for <time datetime="{{ task.scheduled_for|date:'Y-m-d' }}">{{ task.scheduled_for|date:"l, j F Y" }}</time>{% if task.scheduled_time %} at {{ task.scheduled_time|time:'H:i' }} {{ task.time_zone }}{% endif %}</p>
</div>
<div class="detail-card__actions">
<a class="button button--secondary" href="{% url 'planner:task-update' task.pk %}">Edit task</a>
@@ -28,6 +28,49 @@
</dl>
</div>
</article>
{% if task.is_recurring %}
<section class="subtasks-section" aria-labelledby="occurrences-heading">
<h2 id="occurrences-heading">Upcoming occurrences</h2>
<p class="muted">Each date keeps its own completion state. Edit task changes the series.</p>
<ul class="subtasks-list occurrence-list">
{% for occurrence in occurrences %}
<li>
<div class="occurrence-list__summary">
<strong>{{ occurrence.scheduled_date|date:'l, j F Y' }}</strong>
<span>{% if occurrence.scheduled_time %}{{ occurrence.scheduled_time|time:'H:i' }} · {% endif %}{{ occurrence.get_status_display }}</span>
</div>
<form class="occurrence-list__complete" method="post" action="{% url 'planner:task-toggle-completed' task.pk %}">
{% csrf_token %}
<input type="hidden" name="selected_date" value="{{ occurrence.scheduled_date|date:'Y-m-d' }}">
<input type="hidden" name="return_to_task_detail" value="1">
<button class="button button--compact" type="submit">{% if occurrence.status == 'completed' %}Reopen{% else %}Complete{% endif %} {{ occurrence.scheduled_date|date:'j M' }}</button>
</form>
<form class="occurrence-list__form" method="post" action="{% url 'planner:task-occurrence-update' task.pk %}">
{% csrf_token %}
<input type="hidden" name="scheduled_date" value="{{ occurrence.scheduled_date|date:'Y-m-d' }}">
<label for="occurrence-time-{{ occurrence.pk }}">Time for {{ occurrence.scheduled_date|date:'j M' }}</label>
<input id="occurrence-time-{{ occurrence.pk }}" type="time" name="scheduled_time" value="{{ occurrence.scheduled_time|time:'H:i' }}">
<button class="button button--compact" type="submit">Save time</button>
</form>
<form class="occurrence-list__form occurrence-list__form--state" method="post" action="{% url 'planner:task-occurrence-update' task.pk %}">
{% csrf_token %}
<input type="hidden" name="scheduled_date" value="{{ occurrence.scheduled_date|date:'Y-m-d' }}">
<label for="occurrence-status-{{ occurrence.pk }}">State for {{ occurrence.scheduled_date|date:'j M' }}</label>
<select id="occurrence-status-{{ occurrence.pk }}" name="status">
<option value="pending"{% if occurrence.status == 'pending' %} selected{% endif %}>Pending</option>
<option value="completed"{% if occurrence.status == 'completed' %} selected{% endif %}>Completed</option>
<option value="skipped"{% if occurrence.status == 'skipped' %} selected{% endif %}>Skipped</option>
<option value="snoozed"{% if occurrence.status == 'snoozed' %} selected{% endif %}>Snoozed</option>
</select>
<label for="occurrence-snooze-{{ occurrence.pk }}">Snooze until</label>
<input id="occurrence-snooze-{{ occurrence.pk }}" type="date" name="snoozed_until" value="{{ occurrence.snoozed_until|date:'Y-m-d' }}">
<button class="button button--compact" type="submit">Save state</button>
</form>
</li>
{% endfor %}
</ul>
</section>
{% endif %}
{% if task.subtasks.all %}
<section class="subtasks-section" aria-labelledby="subtasks-heading">
<p class="eyebrow">Break it down</p>
+36
View File
@@ -0,0 +1,36 @@
from datetime import date
from django.db import connection
from django.db.migrations.executor import MigrationExecutor
from django.test import TransactionTestCase
class OccurrenceMigrationTests(TransactionTestCase):
migrate_from = ('planner', '0022_usersettings_is_demo')
migrate_to = ('planner', '0024_taskoccurrenceevent_from_snoozed_until_and_more')
def test_existing_completion_is_preserved_without_fabricated_history(self):
executor = MigrationExecutor(connection)
executor.migrate([self.migrate_from])
old_apps = executor.loader.project_state([self.migrate_from]).apps
User = old_apps.get_model('auth', 'User')
Settings = old_apps.get_model('planner', 'UserSettings')
Task = old_apps.get_model('planner', 'Task')
user = User.objects.create(username='migration-owner')
Settings.objects.create(user_id=user.pk, time_zone='America/New_York')
one_off = Task.objects.create(owner_id=user.pk, title='One-off', scheduled_for=date(2026, 1, 2), is_completed=True)
recurring = Task.objects.create(owner_id=user.pk, title='Weekly', scheduled_for=date(2026, 1, 7),
is_completed=True, is_recurring=True, recurrence_interval=1, recurrence_unit='week')
Task.objects.create(owner_id=user.pk, title='Pending', scheduled_for=date(2026, 1, 3))
executor = MigrationExecutor(connection)
executor.migrate([self.migrate_to])
apps = executor.loader.project_state([self.migrate_to]).apps
NewTask = apps.get_model('planner', 'Task')
Occurrence = apps.get_model('planner', 'TaskOccurrence')
Event = apps.get_model('planner', 'TaskOccurrenceEvent')
self.assertTrue(NewTask.objects.get(pk=one_off.pk).is_completed)
self.assertFalse(NewTask.objects.get(pk=recurring.pk).is_completed)
self.assertEqual(NewTask.objects.get(pk=recurring.pk).time_zone, 'America/New_York')
self.assertEqual(Occurrence.objects.filter(status='completed').count(), 2)
self.assertFalse(Event.objects.exists())
+84
View File
@@ -0,0 +1,84 @@
from datetime import date, time
from django.contrib.auth import get_user_model
from django.core.exceptions import ValidationError
from django.test import TestCase, override_settings
from django.urls import reverse
from planner.models import Task, TaskOccurrence, TaskOccurrenceEvent
from planner.services.occurrences import occurrence_for_date, override_occurrence_time, set_occurrence_status, validate_local_time
from planner.services.scheduling import is_task_eligible
@override_settings(SECURE_SSL_REDIRECT=False)
class TaskOccurrenceTests(TestCase):
def setUp(self):
self.user = get_user_model().objects.create_user('owner', password='test')
self.other = get_user_model().objects.create_user('other', password='test')
self.task = Task.objects.create(
owner=self.user, title='Fold clothes', scheduled_for=date(2026, 10, 28),
scheduled_time=time(11), time_zone='Europe/Amsterdam', is_recurring=True,
recurrence_unit=Task.RecurrenceUnit.WEEK, recurrence_interval=1,
)
def test_wednesdays_have_independent_state_and_generation_is_idempotent(self):
first = occurrence_for_date(self.task, date(2026, 10, 28))
self.assertEqual(first.pk, occurrence_for_date(self.task, date(2026, 10, 28)).pk)
set_occurrence_status(self.user, self.task.pk, first.scheduled_date, 'completed')
second = occurrence_for_date(self.task, date(2026, 11, 4))
self.assertEqual(second.status, 'pending')
self.assertEqual(second.scheduled_time, time(11))
self.assertEqual(TaskOccurrenceEvent.objects.filter(occurrence=first).count(), 1)
with self.assertRaises(ValidationError):
occurrence_for_date(self.task, date(2026, 10, 29))
def test_occurrence_time_override_survives_series_edit(self):
day = date(2026, 11, 4)
override_occurrence_time(self.user, self.task.pk, day, time(12))
self.task.scheduled_time = time(10)
self.task.save(update_fields=['scheduled_time'])
self.assertEqual(occurrence_for_date(self.task, day).scheduled_time, time(12))
self.assertEqual(occurrence_for_date(self.task, date(2026, 11, 11)).scheduled_time, time(10))
def test_dst_gap_rejected_and_overlap_uses_first_fold(self):
with self.assertRaises(ValidationError):
validate_local_time(date(2027, 3, 28), time(2, 30), 'Europe/Amsterdam')
validate_local_time(date(2027, 10, 31), time(2, 30), 'Europe/Amsterdam')
def test_spring_gap_occurrence_moves_to_first_valid_time(self):
self.task.scheduled_for = date(2027, 3, 21)
self.task.scheduled_time = time(2, 30)
self.task.save(update_fields=['scheduled_for', 'scheduled_time'])
occurrence = occurrence_for_date(self.task, date(2027, 3, 28))
self.assertEqual(occurrence.scheduled_time, time(3))
def test_skip_and_snooze_keep_separate_state_and_history(self):
first = date(2026, 10, 28)
second = date(2026, 11, 4)
set_occurrence_status(self.user, self.task.pk, first, 'skipped')
self.assertFalse(is_task_eligible(self.task, first))
set_occurrence_status(self.user, self.task.pk, second, 'snoozed', snoozed_until=date(2026, 11, 5))
self.assertFalse(is_task_eligible(self.task, second))
self.assertTrue(is_task_eligible(self.task, date(2026, 11, 5)))
set_occurrence_status(self.user, self.task.pk, first, 'pending')
self.assertEqual(TaskOccurrenceEvent.objects.filter(occurrence__task=self.task).count(), 3)
def test_other_user_cannot_change_occurrence(self):
self.client.force_login(self.other)
response = self.client.post(reverse('planner:task-occurrence-update', args=[self.task.pk]), {
'scheduled_date': '2026-11-04', 'status': 'completed',
})
self.assertEqual(response.status_code, 404)
self.assertFalse(TaskOccurrence.objects.filter(task=self.task).exists())
def test_detail_lists_dates_and_completion_is_date_specific(self):
self.client.force_login(self.user)
response = self.client.get(reverse('planner:task-detail', args=[self.task.pk]))
self.assertContains(response, 'Upcoming occurrences')
self.assertContains(response, '11:00')
self.client.post(reverse('planner:task-toggle-completed', args=[self.task.pk]), {
'selected_date': '2026-10-28', 'return_to_task_detail': '1',
})
self.assertEqual(TaskOccurrence.objects.get(task=self.task, scheduled_date=date(2026, 10, 28)).status, 'completed')
self.task.refresh_from_db()
self.assertFalse(self.task.is_completed)
+2 -1
View File
@@ -6,7 +6,7 @@ from .health_exports import export_bowel_csv, export_pain_csv
from .views import (
DailyPlannerView, HealthView, TaskCreateView, category_suggestions, TaskDeleteView, TaskDetailView, TaskListView,
TaskUpdateView, WorkoutCreateView, WorkoutUpdateView, delete_workout, fasting_configure, neck_headache_checkin_panel,
fasting_toggle_tracking, fasting_widget, logout_view, register, toggle_task_active, toggle_task_completed,
fasting_toggle_tracking, fasting_widget, logout_view, register, toggle_task_active, toggle_task_completed, update_task_occurrence,
save_neck_headache_checkin, save_sleep_checkin, advance_onboarding, toggle_workout_completed, user_settings, workout_today,
bowel_health_panel, save_bowel_health_checkin, toggle_tooth_brushing, hydration_add, hydration_undo, hydration_panel, test_ntfy, gitea_activity,
)
@@ -50,4 +50,5 @@ urlpatterns = [
path('tasks/<int:pk>/delete/', TaskDeleteView.as_view(), name='task-delete'),
path('tasks/<int:pk>/toggle-active/', toggle_task_active, name='task-toggle-active'),
path('tasks/<int:pk>/toggle-completed/', toggle_task_completed, name='task-toggle-completed'),
path('tasks/<int:pk>/occurrence/', update_task_occurrence, name='task-occurrence-update'),
]
+45 -3
View File
@@ -13,7 +13,7 @@ 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.utils.dateparse import parse_date, parse_time
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
@@ -36,6 +36,8 @@ from .services.fasting import (
synchronize_fasting_periods,
)
from .services.scheduling import daily_recommendations, duration_budget_for_energy
from .services.occurrences import upcoming_occurrences, set_occurrence_status, override_occurrence_time
from .models import TaskOccurrence
from .services.workouts import toggle_workout_completion, workouts_for_day
from .timezones import localdate_for_user
from .services.weather import (
@@ -587,6 +589,8 @@ class TaskDetailView(OwnedTaskQuerysetMixin, DetailView):
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
add_predicted_weather(self.request.user, [context['task']])
task = context['task']
context['occurrences'] = upcoming_occurrences(task, localdate_for_user(self.request.user), 8) if task.is_recurring else task.occurrences.order_by('scheduled_date')[:8]
return context
@@ -699,8 +703,19 @@ def delete_workout(request, pk):
@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'])
selected_date = parse_date(request.POST.get('selected_date', ''))
if task.is_recurring and selected_date is None:
return HttpResponse('Choose an occurrence date.', status=400)
occurrence_date = selected_date if task.is_recurring else task.scheduled_for
try:
current = task.occurrences.filter(scheduled_date=occurrence_date).first()
completed = current.status == TaskOccurrence.Status.COMPLETED if current else task.is_completed and not task.is_recurring
set_occurrence_status(request.user, task.pk, occurrence_date,
TaskOccurrence.Status.PENDING if completed else TaskOccurrence.Status.COMPLETED)
except ValidationError as exc:
return HttpResponse(str(exc), status=400)
if request.POST.get('return_to_task_detail'):
return redirect('planner:task-detail', pk=pk)
if request.POST.get('return_to_daily_planner'):
selected_date = parse_date(request.POST.get('selected_date')) or timezone.localdate()
try:
@@ -722,6 +737,33 @@ def toggle_task_completed(request, pk):
return render_task_list(request, current_filter)
@login_required
@require_POST
def update_task_occurrence(request, pk):
day = parse_date(request.POST.get('scheduled_date', ''))
task = get_object_or_404(Task, pk=pk, owner=request.user, is_recurring=True)
if day is None:
return HttpResponse('Choose a valid occurrence date.', status=400)
try:
if 'scheduled_time' in request.POST:
clock_text = request.POST['scheduled_time']
clock = parse_time(clock_text) if clock_text else None
if clock_text and clock is None:
raise ValidationError('Choose a valid time.')
override_occurrence_time(request.user, task.pk, day, clock)
elif 'status' in request.POST:
status = request.POST['status']
snoozed_until = parse_date(request.POST.get('snoozed_until', '')) if status == 'snoozed' else None
if status == 'snoozed' and (snoozed_until is None or snoozed_until <= day):
raise ValidationError('Choose a snooze date after the scheduled date.')
set_occurrence_status(request.user, task.pk, day, status, snoozed_until=snoozed_until)
else:
raise ValidationError('Choose an occurrence change.')
except ValidationError as exc:
return HttpResponse(str(exc), status=400)
return redirect('planner:task-detail', pk=pk)
@login_required
@require_POST
def toggle_task_active(request, pk):