Files
Django_TasksApp/main/planner/services/occurrences.py
T

108 lines
4.6 KiB
Python

"""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