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