mygpo/api/advanced/lists.py

   1 import uuid
   2 from functools import partial
   3 from datetime import datetime
   4
   5 from django.http import HttpResponse, HttpResponseBadRequest, \
   6      HttpResponseForbidden
   7 from django.views.decorators.csrf import csrf_exempt
   8 from django.core.urlresolvers import reverse
   9 from django.contrib.sites.requests import RequestSite
  10 from django.contrib.auth import get_user_model
  11 from django.utils.text import slugify
  12 from django.views.decorators.cache import never_cache
  13 from django.http import Http404
  14 from django.shortcuts import get_object_or_404
  15
  16 from mygpo.podcasts.models import Podcast
  17 from mygpo.utils import get_timestamp
  18 from mygpo.api.advanced.directory import podcast_data
  19 from mygpo.api.httpresponse import JsonResponse
  20 from mygpo.podcastlists.models import PodcastList
  21 from mygpo.api.basic_auth import require_valid_user, check_username
  22 from mygpo.decorators import allowed_methods, cors_origin
  23 from mygpo.api.simple import parse_subscription, format_podcast_list, \
  24      check_format
  25 from mygpo.podcastlists.views import list_decorator
  26
  27
  28 @csrf_exempt
  29 @require_valid_user
  30 @check_username
  31 @check_format
  32 @never_cache
  33 @allowed_methods(['POST'])
  34 @cors_origin()
  35 def create(request, username, format):
  36     """ Creates a new podcast list and links to it in the Location header """
  37
  38     title = request.GET.get('title', None)
  39
  40     if not title:
  41         return HttpResponseBadRequest('Title missing')
  42
  43     slug = slugify(title)
  44
  45     if not slug:
  46         return HttpResponseBadRequest('Invalid title')
  47
  48     plist, created = PodcastList.objects.get_or_create(
  49         user=request.user,
  50         slug=slug,
  51         defaults={
  52             'id': uuid.uuid1(),
  53             'title': title,
  54             'slug': slug,
  55             'created': datetime.utcnow(),
  56             'modified': datetime.utcnow(),
  57         }
  58     )
  59
  60     if not created:
  61         return HttpResponse('List already exists', status=409)
  62
  63     urls = parse_subscription(request.body.decode('utf-8'), format)
  64     podcasts = [Podcast.objects.get_or_create_for_url(url) for url in urls]
  65
  66     for podcast in podcasts:
  67         plist.add_entry(podcast)
  68
  69     response = HttpResponse(status=201)
  70     list_url = reverse('api-get-list', args=[request.user.username, slug, format])
  71     response['Location'] = list_url
  72
  73     return response
  74
  75
  76
  77 def _get_list_data(l, username, domain):
  78     return dict(
  79             title= l.title,
  80             name = l.slug,
  81             web  = 'http://%s%s' % (domain,
  82                 reverse('list-show', args=[username, l.slug])),
  83         )
  84
  85
  86 @csrf_exempt
  87 @never_cache
  88 @allowed_methods(['GET'])
  89 @cors_origin()
  90 def get_lists(request, username):
  91     """ Returns a list of all podcast lists by the given user """
  92
  93     User = get_user_model()
  94     user = User.objects.get(username=username)
  95     if not user:
  96         raise Http404
  97
  98     lists = PodcastList.objects.filter(user=user)
  99
 100     site = RequestSite(request)
 101
 102     get_data = partial(_get_list_data, username=user.username,
 103                 domain=site.domain)
 104     lists_data = list(map(get_data, lists))
 105
 106     return JsonResponse(lists_data)
 107
 108
 109 @csrf_exempt
 110 @check_format
 111 @never_cache
 112 @allowed_methods(['GET', 'PUT', 'DELETE'])
 113 @cors_origin()
 114 def podcast_list(request, username, slug, format):
 115
 116     handlers = dict(
 117             GET = get_list,
 118             PUT = update_list,
 119             DELETE = delete_list,
 120         )
 121     return handlers[request.method](request, username, slug, format)
 122
 123
 124 @list_decorator(must_own=False)
 125 @cors_origin()
 126 def get_list(request, plist, owner, format):
 127     """ Returns the contents of the podcast list """
 128
 129     try:
 130         scale = int(request.GET.get('scale_logo', 64))
 131     except (TypeError, ValueError):
 132         return HttpResponseBadRequest('scale_logo has to be a numeric value')
 133
 134     domain = RequestSite(request).domain
 135     p_data = lambda p: podcast_data(p, domain, scale)
 136     title = '{title} by {username}'.format(title=plist.title,
 137             username=owner.username)
 138
 139     objs = [entry.content_object for entry in plist.entries.all()]
 140
 141     return format_podcast_list(objs, format, title, json_map=p_data,
 142             jsonp_padding=request.GET.get('jsonp', ''),
 143             xml_template='podcasts.xml', request=request)
 144
 145
 146 @list_decorator(must_own=True)
 147 @cors_origin()
 148 def update_list(request, plist, owner, format):
 149     """ Replaces the podcasts in the list and returns 204 No Content """
 150     urls = parse_subscription(request.body.decode('utf-8'), format)
 151     podcasts = [Podcast.objects.get_or_create_for_url(url) for url in urls]
 152     plist.set_entries(podcasts)
 153
 154     return HttpResponse(status=204)
 155
 156
 157 @list_decorator(must_own=True)
 158 @cors_origin()
 159 def delete_list(request, plist, owner, format):
 160     """ Delete the podcast list and returns 204 No Content """
 161     plist.delete()
 162     return HttpResponse(status=204)