118 lines
5.0 KiB
Python
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))
|