Files
Django_TasksApp/main/stress/api.py
T
2026-10-19 16:51:53 +02:00

118 lines
5.0 KiB
Python

"""Owner-scoped stress journal API used by the MCP adapter."""
from datetime import datetime, timedelta, time
from django.core.exceptions import ValidationError
from django.db.models import Q
from django.http import JsonResponse
from django.utils import timezone
from django.utils.dateparse import parse_date, parse_datetime
from food.api import api_view, error, _json, _idempotent
from planner.timezones import timezone_for_user
from .forms import normalize_symptoms, normalize_tags
from .models import StressEntry
FIELDS = {'recorded_at', 'timing', 'score', 'note', 'tags', 'symptoms'}
def serialize(entry):
return {'id': str(entry.pk), 'recorded_at': entry.recorded_at.isoformat(),
'timing': entry.timing, 'score': entry.score, 'note': entry.note,
'tags': entry.tags, 'symptoms': entry.symptoms,
'created_at': entry.created_at.isoformat(), 'updated_at': entry.updated_at.isoformat()}
def validate(data, user):
if unknown := set(data) - FIELDS:
raise ValueError('Unknown fields: ' + ', '.join(sorted(unknown)))
cleaned = {}
if 'recorded_at' in data:
value = parse_datetime(data['recorded_at']) if isinstance(data['recorded_at'], str) else None
if value is None:
raise ValueError('Use an ISO date and time for recorded_at.')
if timezone.is_naive(value):
value = timezone.make_aware(value, timezone_for_user(user))
cleaned['recorded_at'] = value
if 'timing' in data:
if data['timing'] not in StressEntry.Timing.values:
raise ValueError('Invalid timing.')
cleaned['timing'] = data['timing']
if 'score' in data:
if isinstance(data['score'], bool) or not isinstance(data['score'], int) or not 0 <= data['score'] <= 10:
raise ValueError('Score must be an integer from 0 to 10.')
cleaned['score'] = data['score']
if 'note' in data:
if not isinstance(data['note'], str) or len(data['note']) > 2000:
raise ValueError('Note must be text up to 2000 characters.')
cleaned['note'] = data['note']
if 'tags' in data:
cleaned['tags'] = normalize_tags(data['tags'])
if 'symptoms' in data:
cleaned['symptoms'] = normalize_symptoms(data['symptoms'])
return cleaned
@api_view({'GET': 'journal:read', 'POST': 'journal:write'}, ('GET', 'POST'))
def collection(request):
if request.method == 'GET':
entries = StressEntry.objects.filter(user=request.api_user)
query = request.GET.get('query', '').strip()[:100]
if query:
entries = entries.filter(Q(note__icontains=query) | Q(tags__icontains=query))
timing = request.GET.get('timing')
if timing:
if timing not in StressEntry.Timing.values:
return error('invalid_timing', 'Invalid timing.')
entries = entries.filter(timing=timing)
date_text = request.GET.get('date')
if date_text:
day = parse_date(date_text)
if day is None or day.isoformat() != date_text:
return error('invalid_date', 'Use YYYY-MM-DD.')
zone = timezone_for_user(request.api_user)
start = timezone.make_aware(datetime.combine(day, time.min), zone)
end = timezone.make_aware(datetime.combine(day + timedelta(days=1), time.min), zone)
entries = entries.filter(recorded_at__gte=start, recorded_at__lt=end)
try:
limit = min(max(int(request.GET.get('limit', 30)), 1), 100)
offset = max(int(request.GET.get('offset', 0)), 0)
except ValueError:
return error('invalid_pagination', 'Limit and offset must be integers.')
return JsonResponse({'items': [serialize(entry) for entry in entries[offset:offset + limit]],
'total': entries.count()})
data = _json(request)
if 'score' not in data:
return error('missing_score', 'Score is required.')
cleaned = validate(data, request.api_user)
def action():
entry = StressEntry(user=request.api_user, **cleaned)
entry.full_clean()
entry.save()
return JsonResponse(serialize(entry), status=201)
return _idempotent(request, data, action)
@api_view({'GET': 'journal:read', 'PATCH': 'journal:write', 'DELETE': 'journal:write'},
('GET', 'PATCH', 'DELETE'))
def item(request, identifier):
entry = StressEntry.objects.filter(pk=identifier, user=request.api_user).first()
if entry is None:
return error('not_found', 'Stress entry not found.', 404)
if request.method == 'GET':
return JsonResponse(serialize(entry))
if request.method == 'DELETE':
entry.delete()
return JsonResponse({'deleted': True})
data = validate(_json(request), request.api_user)
previous_score = entry.score
for name, value in data.items():
setattr(entry, name, value)
if 'score' in data and entry.daily_date is not None:
entry.record_score(data['score'], previous_score=previous_score)
entry.full_clean()
entry.save()
return JsonResponse(serialize(entry))