130 lines
5.8 KiB
Python
130 lines
5.8 KiB
Python
import hashlib
|
|
import json
|
|
import secrets
|
|
from datetime import timedelta
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.core.exceptions import ValidationError
|
|
from django.core.cache import cache
|
|
from django.http import JsonResponse
|
|
from django.shortcuts import get_object_or_404, redirect, render
|
|
from django.utils import timezone
|
|
from django.views.decorators.csrf import csrf_exempt
|
|
from django.views.decorators.http import require_POST
|
|
|
|
from .models import CaptureToken, SavedItem
|
|
from .services import save_item, search_items
|
|
|
|
|
|
@login_required
|
|
def index(request):
|
|
query = request.GET.get('q', '').strip()[:200]
|
|
items = search_items(request.user, query, 100) if query else SavedItem.objects.filter(owner=request.user).exclude(status=SavedItem.Status.ARCHIVED)[:100]
|
|
return render(request, 'knowledge/index.html', {'title': 'Knowledge Library', 'section': 'knowledge', 'items': items, 'query': query})
|
|
|
|
|
|
@login_required
|
|
def item_card(request, item_id):
|
|
item = get_object_or_404(SavedItem, pk=item_id, owner=request.user)
|
|
response = render(request, 'knowledge/_item_card.html', {'item': item})
|
|
response['Cache-Control'] = 'private, no-store'
|
|
return response
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def add(request):
|
|
try:
|
|
item, created = save_item(request.user, request.POST.get('url'),
|
|
title=request.POST.get('title', '').strip()[:300],
|
|
notes=request.POST.get('notes', '').strip()[:3000],
|
|
saved_reason=request.POST.get('saved_reason', '').strip()[:300])
|
|
except ValidationError as exc:
|
|
return render(request, 'knowledge/index.html', {'title': 'Knowledge Library', 'section': 'knowledge',
|
|
'items': SavedItem.objects.filter(owner=request.user)[:100], 'error': exc.messages[0], 'form_url': request.POST.get('url', '')}, status=400)
|
|
return redirect('knowledge:index')
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def archive(request, item_id):
|
|
item = get_object_or_404(SavedItem, pk=item_id, owner=request.user)
|
|
item.status = SavedItem.Status.ARCHIVED
|
|
item.save(update_fields=['status', 'updated_at'])
|
|
return redirect('knowledge:index')
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def edit(request, item_id):
|
|
item = get_object_or_404(SavedItem, pk=item_id, owner=request.user)
|
|
mode = request.POST.get('preview_mode', 'preview')
|
|
if mode not in ('preview', 'plain', 'embed') or (mode == 'embed' and item.provider != 'youtube'):
|
|
return JsonResponse({'error': 'Invalid preview mode'}, status=400)
|
|
item.title = request.POST.get('title', '').strip()[:300]
|
|
item.user_description = request.POST.get('description', '').strip()[:2000]
|
|
item.preview_mode = mode
|
|
item.save(update_fields=['title', 'user_description', 'preview_mode', 'updated_at'])
|
|
return redirect('knowledge:index')
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def refresh(request, item_id):
|
|
item = get_object_or_404(SavedItem, pk=item_id, owner=request.user)
|
|
if item.metadata_fetched_at and item.metadata_fetched_at > timezone.now() - timedelta(minutes=5):
|
|
return redirect('knowledge:index')
|
|
item.metadata_status = SavedItem.MetadataStatus.PENDING
|
|
item.metadata_retry_at = None
|
|
item.metadata_error = ''
|
|
item.metadata_attempts = 0
|
|
item.save(update_fields=['metadata_status', 'metadata_retry_at', 'metadata_error', 'metadata_attempts', 'updated_at'])
|
|
return redirect('knowledge:index')
|
|
|
|
|
|
@login_required
|
|
def tokens(request):
|
|
secret = None
|
|
if request.method == 'POST':
|
|
if request.POST.get('action') == 'revoke':
|
|
token = get_object_or_404(CaptureToken, pk=request.POST.get('token_id'), owner=request.user)
|
|
token.revoked_at = timezone.now()
|
|
token.save(update_fields=['revoked_at'])
|
|
else:
|
|
secret = secrets.token_urlsafe(32)
|
|
CaptureToken.objects.create(owner=request.user, name=request.POST.get('name', 'Apple Shortcut')[:80],
|
|
token_hash=hashlib.sha256(secret.encode()).hexdigest())
|
|
return render(request, 'knowledge/tokens.html', {'title': 'Capture tokens', 'section': 'knowledge',
|
|
'tokens': CaptureToken.objects.filter(owner=request.user).order_by('-created_at'), 'secret': secret})
|
|
|
|
|
|
@csrf_exempt
|
|
@require_POST
|
|
def api_add(request):
|
|
if len(request.body) > 16_384:
|
|
return JsonResponse({'error': 'Request too large'}, status=413)
|
|
header = request.headers.get('Authorization', '')
|
|
if not header.startswith('Bearer ') or len(header) > 180:
|
|
return JsonResponse({'error': 'Bearer capture token required'}, status=401)
|
|
token_hash = hashlib.sha256(header[7:].encode()).hexdigest()
|
|
token = CaptureToken.objects.select_related('owner').filter(token_hash=token_hash, revoked_at__isnull=True).first()
|
|
if token is None:
|
|
return JsonResponse({'error': 'Invalid capture token'}, status=401)
|
|
rate_key = f'knowledge-capture:{token.pk}:{timezone.now():%Y%m%d%H%M}'
|
|
if not cache.add(rate_key, 1, 90):
|
|
try:
|
|
if cache.incr(rate_key) > 30:
|
|
return JsonResponse({'error': 'Too many captures; try again shortly'}, status=429)
|
|
except ValueError:
|
|
cache.set(rate_key, 1, 90)
|
|
try:
|
|
payload = json.loads(request.body)
|
|
if not isinstance(payload, dict):
|
|
raise ValueError()
|
|
item, created = save_item(token.owner, payload.get('url'),
|
|
title=str(payload.get('title') or '')[:300], notes=str(payload.get('notes') or '')[:3000],
|
|
saved_reason=str(payload.get('saved_reason') or '')[:300])
|
|
except (ValueError, TypeError, ValidationError) as exc:
|
|
return JsonResponse({'error': str(exc) or 'Invalid JSON'}, status=400)
|
|
return JsonResponse({'id': str(item.pk), 'created': created, 'duplicate': not created,
|
|
'url': item.original_url, 'metadata_status': item.metadata_status}, status=201 if created else 200)
|