mygpo/web/views/episode.py

   1 #
   2 # This file is part of my.gpodder.org.
   3 #
   4 # my.gpodder.org is free software: you can redistribute it and/or modify it
   5 # under the terms of the GNU Affero General Public License as published by
   6 # the Free Software Foundation, either version 3 of the License, or (at your
   7 # option) any later version.
   8 #
   9 # my.gpodder.org is distributed in the hope that it will be useful, but
  10 # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11 # or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public
  12 # License for more details.
  13 #
  14 # You should have received a copy of the GNU Affero General Public License
  15 # along with my.gpodder.org. If not, see <http://www.gnu.org/licenses/>.
  16 #
  17
  18 from datetime import datetime
  19 from functools import wraps
  20
  21 import dateutil.parser
  22
  23 from django.shortcuts import render
  24 from django.http import HttpResponseRedirect, Http404
  25 from django.contrib.auth.decorators import login_required
  26 from django.contrib.sites.models import RequestSite
  27 from django.views.decorators.vary import vary_on_cookie
  28 from django.views.decorators.cache import never_cache, cache_control
  29 from django.contrib import messages
  30 from django.utils.translation import ugettext as _
  31
  32 from mygpo.api.constants import EPISODE_ACTION_TYPES
  33 from mygpo.decorators import repeat_on_conflict
  34 from mygpo.core.proxy import proxy_object
  35 from mygpo.core.tasks import flattr_thing
  36 from mygpo.users.models import Chapter, HistoryEntry, EpisodeAction
  37 from mygpo.utils import parse_time, get_timestamp
  38 from mygpo.users.settings import FLATTR_TOKEN
  39 from mygpo.web.heatmap import EpisodeHeatmap
  40 from mygpo.web.utils import get_episode_link_target, fetch_episode_data
  41 from mygpo.db.couchdb.episode import episode_for_slug_id, episode_for_oldid, \
  42          favorite_episodes_for_user, chapters_for_episode
  43 from mygpo.db.couchdb.podcast import podcast_by_id, podcast_for_url, \
  44          podcasts_to_dict
  45 from mygpo.db.couchdb.episode_state import episode_state_for_user_episode, \
  46          add_episode_actions
  47 from mygpo.db.couchdb.user import get_latest_episodes
  48 from mygpo.userfeeds.feeds import FavoriteFeed
  49
  50
  51 @vary_on_cookie
  52 @cache_control(private=True)
  53 def episode(request, episode):
  54
  55     podcast = podcast_by_id(episode.podcast)
  56
  57     if not podcast:
  58         raise Http404
  59
  60     if request.user.is_authenticated():
  61
  62         episode_state = episode_state_for_user_episode(request.user, episode)
  63         is_fav = episode_state.is_favorite()
  64
  65
  66         # pre-populate data for fetch_data
  67         podcasts_dict = {podcast.get_id(): podcast}
  68         episodes_dict = {episode._id: episode}
  69
  70         history = list(episode_state.get_history_entries())
  71         HistoryEntry.fetch_data(request.user, history,
  72                 podcasts=podcasts_dict, episodes=episodes_dict)
  73
  74         played_parts = EpisodeHeatmap(podcast.get_id(),
  75                 episode._id, request.user._id, duration=episode.duration)
  76
  77         devices = dict( (d.id, d.name) for d in request.user.devices )
  78         can_flattr = request.user.get_wksetting(FLATTR_TOKEN) and episode.flattr_url
  79
  80     else:
  81         history = []
  82         is_fav = False
  83         played_parts = None
  84         devices = {}
  85         can_flattr = False
  86
  87
  88     chapters = []
  89     for user, chapter in chapters_for_episode(episode._id):
  90         chapter.is_own = request.user.is_authenticated() and \
  91                          user == request.user._id
  92         chapters.append(chapter)
  93
  94
  95     prev = podcast.get_episode_before(episode)
  96     next = podcast.get_episode_after(episode)
  97
  98     return render(request, 'episode.html', {
  99         'episode': episode,
 100         'podcast': podcast,
 101         'prev': prev,
 102         'next': next,
 103         'history': history,
 104         'chapters': chapters,
 105         'is_favorite': is_fav,
 106         'played_parts': played_parts,
 107         'actions': EPISODE_ACTION_TYPES,
 108         'devices': devices,
 109         'can_flattr': can_flattr,
 110     })
 111
 112
 113 @never_cache
 114 @login_required
 115 def add_chapter(request, episode):
 116     e_state = episode_state_for_user_episode(request.user, episode)
 117
 118     podcast = podcast_by_id(episode.podcast)
 119
 120     try:
 121         start = parse_time(request.POST.get('start', '0'))
 122
 123         if request.POST.get('end', '0'):
 124             end = parse_time(request.POST.get('end', '0'))
 125         else:
 126             end = start
 127
 128         adv = 'advertisement' in request.POST
 129         label = request.POST.get('label')
 130
 131     except ValueError as e:
 132         messages.error(request,
 133                 _('Could not add Chapter: {msg}'.format(msg=str(e))))
 134
 135         return HttpResponseRedirect(get_episode_link_target(episode, podcast))
 136
 137
 138     chapter = Chapter()
 139     chapter.start = start
 140     chapter.end = end
 141     chapter.advertisement = adv
 142     chapter.label = label
 143
 144     e_state.update_chapters(add=[chapter])
 145
 146     return HttpResponseRedirect(get_episode_link_target(episode, podcast))
 147
 148
 149 @never_cache
 150 @login_required
 151 def remove_chapter(request, episode, start, end):
 152     e_state = episode_state_for_user_episode(request.user, episode)
 153
 154     remove = (int(start), int(end))
 155     e_state.update_chapters(rem=[remove])
 156
 157     podcast = podcast_by_id(episode.podcast)
 158
 159     return HttpResponseRedirect(get_episode_link_target(episode, podcast))
 160
 161
 162 @never_cache
 163 @login_required
 164 def toggle_favorite(request, episode):
 165     episode_state = episode_state_for_user_episode(request.user, episode)
 166
 167     @repeat_on_conflict(['episode_state'])
 168     def _set_fav(episode_state, is_fav):
 169         episode_state.set_favorite(is_fav)
 170         episode_state.save()
 171
 172     is_fav = episode_state.is_favorite()
 173     _set_fav(episode_state=episode_state, is_fav=not is_fav)
 174
 175     podcast = podcast_by_id(episode.podcast)
 176
 177     return HttpResponseRedirect(get_episode_link_target(episode, podcast))
 178
 179
 180
 181 @vary_on_cookie
 182 @cache_control(private=True)
 183 @login_required
 184 def list_favorites(request):
 185     user = request.user
 186     site = RequestSite(request)
 187
 188     episodes = favorite_episodes_for_user(user)
 189
 190     recently_listened = get_latest_episodes(user)
 191
 192     podcast_ids = [episode.podcast for episode in episodes + recently_listened]
 193     podcasts = podcasts_to_dict(podcast_ids)
 194
 195     recently_listened = fetch_episode_data(recently_listened, podcasts=podcasts)
 196     episodes = fetch_episode_data(episodes, podcasts=podcasts)
 197
 198     favfeed = FavoriteFeed(user)
 199     feed_url = favfeed.get_public_url(site.domain)
 200
 201     podcast = podcast_for_url(feed_url)
 202
 203     token = request.user.favorite_feeds_token
 204
 205     return render(request, 'favorites.html', {
 206         'episodes': episodes,
 207         'feed_token': token,
 208         'site': site,
 209         'podcast': podcast,
 210         'recently_listened': recently_listened,
 211         })
 212
 213
 214 @never_cache
 215 def add_action(request, episode):
 216
 217     device = request.user.get_device(request.POST.get('device'))
 218
 219     action_str = request.POST.get('action')
 220     timestamp = request.POST.get('timestamp', '')
 221
 222     if timestamp:
 223         try:
 224             timestamp = dateutil.parser.parse(timestamp)
 225         except (ValueError, AttributeError):
 226             timestamp = datetime.utcnow()
 227     else:
 228         timestamp = datetime.utcnow()
 229
 230     action = EpisodeAction()
 231     action.timestamp = timestamp
 232     action.upload_timestamp = get_timestamp(datetime.utcnow())
 233     action.device = device.id if device else None
 234     action.action = action_str
 235
 236     state = episode_state_for_user_episode(request.user, episode)
 237     add_episode_actions(state, [action])
 238
 239     podcast = podcast_by_id(episode.podcast)
 240     return HttpResponseRedirect(get_episode_link_target(episode, podcast))
 241
 242
 243 @never_cache
 244 @login_required
 245 def flattr_episode(request, episode):
 246     """ Flattrs an episode, records an event and redirects to the episode """
 247
 248     user = request.user
 249     site = RequestSite(request)
 250
 251     # Flattr via the tasks queue, but wait for the result
 252     task = flattr_thing.delay(user, episode._id, site.domain, 'Episode')
 253     success, msg = task.get()
 254
 255     if success:
 256         action = EpisodeAction()
 257         action.action = 'flattr'
 258         action.upload_timestamp = get_timestamp(datetime.utcnow())
 259         state = episode_state_for_user_episode(request.user, episode)
 260         add_episode_actions(state, [action])
 261         messages.success(request, _("Flattr\'d"))
 262
 263     else:
 264         messages.error(request, msg)
 265
 266     podcast = podcast_by_id(episode.podcast)
 267     return HttpResponseRedirect(get_episode_link_target(episode, podcast))
 268
 269
 270 # To make all view accessible via either CouchDB-ID for Slugs
 271 # a decorator queries the episode and passes the Id on to the
 272 # regular views
 273
 274 def slug_id_decorator(f):
 275     @wraps(f)
 276     def _decorator(request, p_slug_id, e_slug_id, *args, **kwargs):
 277         episode = episode_for_slug_id(p_slug_id, e_slug_id)
 278
 279         if episode is None:
 280             raise Http404
 281
 282         # redirect when Id or a merged (non-cannonical) slug is used
 283         if episode.slug and episode.slug != e_slug_id:
 284             podcast = podcast_by_id(episode.podcast)
 285             return HttpResponseRedirect(
 286                     get_episode_link_target(episode, podcast))
 287
 288         return f(request, episode, *args, **kwargs)
 289
 290     return _decorator
 291
 292
 293 def oldid_decorator(f):
 294     @wraps(f)
 295     def _decorator(request, id, *args, **kwargs):
 296         episode = episode_for_oldid(id)
 297
 298         if episode is None:
 299             raise Http404
 300
 301         # redirect to Id or slug URL
 302         podcast = podcast_by_id(episode.podcast)
 303         return HttpResponseRedirect(get_episode_link_target(episode, podcast))
 304
 305     return _decorator
 306
 307 show_slug_id            = slug_id_decorator(episode)
 308 add_chapter_slug_id     = slug_id_decorator(add_chapter)
 309 remove_chapter_slug_id  = slug_id_decorator(remove_chapter)
 310 toggle_favorite_slug_id = slug_id_decorator(toggle_favorite)
 311 add_action_slug_id      = slug_id_decorator(add_action)
 312 flattr_episode_slug_id  = slug_id_decorator(flattr_episode)
 313
 314 show_oldid            = oldid_decorator(episode)
 315 add_chapter_oldid     = oldid_decorator(add_chapter)
 316 remove_chapter_oldid  = oldid_decorator(remove_chapter)
 317 toggle_favorite_oldid = oldid_decorator(toggle_favorite)
 318 add_action_oldid      = oldid_decorator(add_action)
 319 flattr_episode_oldid  = oldid_decorator(flattr_episode)