mygpo/share/views.py

   1 from functools import wraps
   2 from datetime import datetime
   3
   4 from django.core.urlresolvers import reverse
   5 from django.http import Http404, HttpResponseRedirect, HttpResponseForbidden
   6 from django.shortcuts import render
   7 from django.utils.text import slugify
   8 from django.contrib.sites.models import RequestSite
   9 from django.contrib.auth.decorators import login_required
  10 from django.contrib import messages
  11 from django.utils.translation import ugettext as _
  12 from django.views.decorators.vary import vary_on_cookie
  13 from django.views.decorators.cache import cache_control
  14 from django.views.generic.base import View
  15 from django.utils.decorators import method_decorator
  16
  17 from mygpo.podcasts.models import Podcast, PodcastGroup
  18 from mygpo.utils import get_timestamp
  19 from mygpo.core.proxy import proxy_object
  20 from mygpo.api.simple import format_podcast_list
  21 from mygpo.share.models import PodcastList
  22 from mygpo.users.models import User
  23 from mygpo.directory.views import search as directory_search
  24 from mygpo.decorators import repeat_on_conflict
  25 from mygpo.flattr import Flattr
  26 from mygpo.userfeeds.feeds import FavoriteFeed
  27 from mygpo.db.couchdb.podcastlist import podcastlist_for_user_slug, \
  28          podcastlists_for_user, add_podcast_to_podcastlist, \
  29          remove_podcast_from_podcastlist, delete_podcastlist
  30 from mygpo.data.feeddownloader import PodcastUpdater
  31
  32
  33
  34 def list_decorator(must_own=False):
  35     def _tmp(f):
  36         @wraps(f)
  37         def _decorator(request, username, listname, *args, **kwargs):
  38
  39             user = User.get_user(username)
  40             if not user:
  41                 raise Http404
  42
  43             if must_own and request.user != user:
  44                 return HttpResponseForbidden()
  45
  46             plist = podcastlist_for_user_slug(user._id, listname)
  47
  48             if plist is None:
  49                 raise Http404
  50
  51             return f(request, plist, user, *args, **kwargs)
  52
  53         return _decorator
  54
  55     return _tmp
  56
  57
  58 @login_required
  59 def search(request, username, listname):
  60     return directory_search(request, 'list_search.html',
  61             {'listname': listname})
  62
  63
  64 @login_required
  65 def lists_own(request):
  66
  67     lists = podcastlists_for_user(request.user._id)
  68
  69     return render(request, 'lists.html', {
  70             'lists': lists
  71         })
  72
  73
  74 def lists_user(request, username):
  75
  76     user = User.get_user(username)
  77     if not user:
  78         raise Http404
  79
  80     lists = podcastlists_for_user(user._id)
  81
  82     return render(request, 'lists_user.html', {
  83             'lists': lists,
  84             'user': user,
  85         })
  86
  87
  88 @list_decorator(must_own=False)
  89 def list_show(request, plist, owner):
  90
  91     is_own = owner == request.user
  92     site = RequestSite(request)
  93
  94     plist = proxy_object(plist)
  95
  96     podcasts = get_podcasts_groups(plist.podcasts)
  97     plist.podcasts = podcasts
  98
  99     max_subscribers = max([p.subscriber_count() for p in podcasts] + [0])
 100
 101     thing = plist.get_flattr_thing(site.domain, owner.username)
 102     flattr = Flattr(owner, site.domain, request.is_secure())
 103     flattr_autosubmit = flattr.get_autosubmit_url(thing)
 104
 105     return render(request, 'list.html', {
 106             'podcastlist': plist,
 107             'max_subscribers': max_subscribers,
 108             'owner': owner,
 109             'flattr_autosubmit': flattr_autosubmit,
 110             'domain': site.domain,
 111             'is_own': is_own,
 112         })
 113
 114
 115 @list_decorator(must_own=False)
 116 def list_opml(request, plist, owner):
 117     podcasts = get_podcasts_groups(plist.podcasts)
 118     return format_podcast_list(podcasts, 'opml', plist.title)
 119
 120
 121 @login_required
 122 def create_list(request):
 123     title = request.POST.get('title', None)
 124
 125     if not title:
 126         messages.error(request, _('You have to specify a title.'))
 127         return HttpResponseRedirect(reverse('lists-overview'))
 128
 129     slug = slugify(title)
 130
 131     if not slug:
 132         messages.error(request, _('"{title}" is not a valid title').format(
 133                     title=title))
 134         return HttpResponseRedirect(reverse('lists-overview'))
 135
 136     plist = podcastlist_for_user_slug(request.user._id, slug)
 137
 138     if plist is None:
 139         plist = PodcastList()
 140         plist.created_timestamp = get_timestamp(datetime.utcnow())
 141         plist.title = title
 142         plist.slug = slug
 143         plist.user = request.user._id
 144         plist.save()
 145
 146     list_url = reverse('list-show', args=[request.user.username, slug])
 147     return HttpResponseRedirect(list_url)
 148
 149
 150 @login_required
 151 @list_decorator(must_own=True)
 152 def add_podcast(request, plist, owner, podcast_id):
 153     add_podcast_to_podcastlist(plist, podcast_id)
 154     list_url = reverse('list-show', args=[owner.username, plist.slug])
 155     return HttpResponseRedirect(list_url)
 156
 157
 158 @login_required
 159 @list_decorator(must_own=True)
 160 def remove_podcast(request, plist, owner, podcast_id):
 161     remove_podcast_from_podcastlist(plist, podcast_id)
 162     list_url = reverse('list-show', args=[owner.username, plist.slug])
 163     return HttpResponseRedirect(list_url)
 164
 165
 166 @login_required
 167 @list_decorator(must_own=True)
 168 def delete_list(request, plist, owner):
 169     delete_podcastlist(plist)
 170     return HttpResponseRedirect(reverse('lists-overview'))
 171
 172
 173 @login_required
 174 @list_decorator(must_own=False)
 175 def rate_list(request, plist, owner):
 176     rating_val = int(request.GET.get('rate', None))
 177
 178     @repeat_on_conflict(['plist'])
 179     def _rate(plist, rating_val, user):
 180         plist.rate(rating_val, user._id)
 181         plist.save()
 182
 183     _rate(plist, rating_val, request.user)
 184
 185     messages.success(request, _('Thanks for rating!'))
 186
 187     list_url = reverse('list-show', args=[owner.username, plist.slug])
 188     return HttpResponseRedirect(list_url)
 189
 190
 191 class FavoritesPublic(View):
 192
 193     public = True
 194
 195     @method_decorator(vary_on_cookie)
 196     @method_decorator(cache_control(private=True))
 197     @method_decorator(login_required)
 198     def post(self, request):
 199
 200         if self.public:
 201             request.user.favorite_feeds_token = ''
 202             request.user.save()
 203
 204         else:
 205             request.user.create_new_token('favorite_feeds_token', 8)
 206             request.user.save()
 207
 208         token = request.user.favorite_feeds_token
 209
 210         return HttpResponseRedirect(reverse('share-favorites'))
 211
 212
 213
 214 class ShareFavorites(View):
 215
 216     @method_decorator(vary_on_cookie)
 217     @method_decorator(cache_control(private=True))
 218     @method_decorator(login_required)
 219     def get(self, request):
 220         user = request.user
 221
 222         favfeed = FavoriteFeed(user)
 223         site = RequestSite(request)
 224         feed_url = favfeed.get_public_url(site.domain)
 225
 226         podcast = Podcast.objects.filter(urls__url=feed_url).first()
 227
 228         token = request.user.favorite_feeds_token
 229
 230         return render(request, 'share/favorites.html', {
 231             'feed_token': token,
 232             'site': site,
 233             'podcast': podcast,
 234             })
 235
 236
 237 class PublicSubscriptions(View):
 238
 239     public = True
 240
 241     @method_decorator(vary_on_cookie)
 242     @method_decorator(cache_control(private=True))
 243     @method_decorator(login_required)
 244     def post(self, request):
 245
 246         self.update(request.user)
 247
 248         return HttpResponseRedirect(reverse('share'))
 249
 250
 251     @repeat_on_conflict(['user'])
 252     def update(self, user):
 253         if self.public:
 254             user.subscriptions_token = ''
 255         else:
 256             user.create_new_token('subscriptions_token')
 257
 258         user.save()
 259
 260
 261 class FavoritesFeedCreateEntry(View):
 262     """ Creates a Podcast object for the user's favorites feed """
 263
 264     @method_decorator(vary_on_cookie)
 265     @method_decorator(cache_control(private=True))
 266     @method_decorator(login_required)
 267     def post(self, request):
 268         user = request.user
 269
 270         feed = FavoriteFeed(user)
 271         site = RequestSite(request)
 272         feed_url = feed.get_public_url(site.domain)
 273
 274         podcast = Podcast.objects.get_or_create_for_url(feed_url)
 275
 276         if not podcast.get_id() in user.published_objects:
 277             user.published_objects.append(podcast.get_id())
 278             user.save()
 279
 280         updater = PodcastUpdater()
 281         updater.update(feed_url)
 282
 283         return HttpResponseRedirect(reverse('share-favorites'))
 284
 285
 286 @login_required
 287 def overview(request):
 288     user = request.user
 289     site = RequestSite(request)
 290
 291     subscriptions_token = user.get_token('subscriptions_token')
 292     userpage_token = user.get_token('userpage_token')
 293     favfeed_token = user.get_token('favorite_feeds_token')
 294
 295     favfeed = FavoriteFeed(user)
 296     favfeed_url = favfeed.get_public_url(site.domain)
 297     favfeed_podcast = Podcast.objects.filter(urls__url=favfeed_url).first()
 298
 299     return render(request, 'share/overview.html', {
 300         'site': site,
 301         'subscriptions_token': subscriptions_token,
 302         'userpage_token': userpage_token,
 303         'favfeed_token': favfeed_token,
 304         'favfeed_podcast': favfeed_podcast,
 305         })
 306
 307
 308 @login_required
 309 def set_token_public(request, token_name, public):
 310
 311     if public:
 312         @repeat_on_conflict(['user'])
 313         def _update(user):
 314             setattr(user, token_name, '')
 315             user.save()
 316
 317     else:
 318         @repeat_on_conflict(['user'])
 319         def _update(user):
 320             user.create_new_token(token_name)
 321             user.save()
 322
 323     _update(user=request.user)
 324
 325     return HttpResponseRedirect(reverse('share'))
 326
 327
 328 def get_podcasts_groups(ids):
 329     # this could be optimized by using a View
 330     groups = PodcastGroup.objects.filter(id__in=ids)
 331     podcasts = PodcastGroup.objects.filter(id__in=ids)
 332     # TODO: bring in right order, according to IDs
 333     return list(groups) + list(podcasts)