mygpo/web/views/settings.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 django.shortcuts import render
  19 from django.core.urlresolvers import reverse
  20 from django.http import HttpResponseRedirect
  21 from django.contrib.auth import logout
  22 from django.contrib import messages
  23 from django.forms import ValidationError
  24 from django.utils.translation import ugettext as _
  25 from django.contrib.auth.decorators import login_required
  26 from django.contrib.contenttypes.models import ContentType
  27 from django.contrib.sites.models import RequestSite
  28 from django.views.decorators.vary import vary_on_cookie
  29 from django.views.decorators.cache import never_cache, cache_control
  30 from django.utils.decorators import method_decorator
  31 from django.views.generic.base import View
  32 from django.utils.html import strip_tags
  33
  34 from mygpo.podcasts.models import Podcast
  35 from mygpo.usersettings.models import UserSettings
  36 from mygpo.decorators import allowed_methods
  37 from mygpo.web.forms import UserAccountForm, ProfileForm, FlattrForm
  38 from mygpo.web.utils import normalize_twitter
  39 from mygpo.flattr import Flattr
  40 from mygpo.users.settings import PUBLIC_SUB_USER, PUBLIC_SUB_PODCAST, \
  41          FLATTR_TOKEN, FLATTR_AUTO, FLATTR_MYGPO, FLATTR_USERNAME
  42
  43
  44 @login_required
  45 @vary_on_cookie
  46 @cache_control(private=True)
  47 @allowed_methods(['GET', 'POST'])
  48 def account(request):
  49
  50     if request.method == 'GET':
  51
  52         site = RequestSite(request)
  53         flattr = Flattr(request.user, site.domain, request.is_secure())
  54         userpage_token = request.user.profile.get_token('userpage_token')
  55
  56         profile_form = ProfileForm({
  57                'twitter': request.user.profile.twitter,
  58                'about':   request.user.profile.about,
  59             })
  60
  61         form = UserAccountForm({
  62             'email': request.user.email,
  63             'public': request.user.profile.settings.get_wksetting(PUBLIC_SUB_USER)
  64             })
  65
  66         flattr_form = FlattrForm({
  67                'enable': request.user.profile.settings.get_wksetting(FLATTR_AUTO),
  68                'token': request.user.profile.settings.get_wksetting(FLATTR_TOKEN),
  69                'flattr_mygpo': request.user.profile.settings.get_wksetting(FLATTR_MYGPO),
  70                'username': request.user.profile.settings.get_wksetting(FLATTR_USERNAME),
  71             })
  72
  73         return render(request, 'account.html', {
  74             'site': site,
  75             'form': form,
  76             'profile_form': profile_form,
  77             'flattr_form': flattr_form,
  78             'flattr': flattr,
  79             'userpage_token': userpage_token,
  80             })
  81
  82     try:
  83         form = UserAccountForm(request.POST)
  84
  85         if not form.is_valid():
  86             raise ValueError(_('Oops! Something went wrong. Please double-check the data you entered.'))
  87
  88         if form.cleaned_data['password_current']:
  89             if not request.user.check_password(form.cleaned_data['password_current']):
  90                 raise ValueError('Current password is incorrect')
  91
  92             request.user.set_password(form.cleaned_data['password1'])
  93
  94         request.user.email = form.cleaned_data['email']
  95
  96         try:
  97             request.user.save()
  98         except Exception as ex:
  99             # TODO: which exception?
 100             messages.error(request, str(ex))
 101
 102         messages.success(request, 'Account updated')
 103
 104     except (ValueError, ValidationError) as e:
 105         messages.error(request, str(e))
 106
 107     return render(request, 'account.html', {
 108         'form': form,
 109     })
 110
 111
 112 class ProfileView(View):
 113     """ Updates the public profile and redirects back to the account view """
 114
 115     def post(self, request):
 116         user = request.user
 117
 118         form = ProfileForm(request.POST)
 119
 120         if not form.is_valid():
 121             raise ValueError(_('Oops! Something went wrong. Please double-check the data you entered.'))
 122
 123         request.user.twitter = normalize_twitter(form.cleaned_data['twitter'])
 124         request.user.about = strip_tags(form.cleaned_data['about'])
 125
 126         request.user.save()
 127         messages.success(request, _('Data updated'))
 128
 129         return HttpResponseRedirect(reverse('account') + '#profile')
 130
 131
 132 class FlattrSettingsView(View):
 133     """ Updates Flattr settings and redirects back to the Account page """
 134
 135     def post(self, request):
 136         user = request.user
 137
 138         form = FlattrForm(request.POST)
 139
 140         if not form.is_valid():
 141             raise ValueError('asdf')
 142
 143         auto_flattr = form.cleaned_data.get('enable', False)
 144         flattr_mygpo = form.cleaned_data.get('flattr_mygpo', False)
 145         username = form.cleaned_data.get('username', '')
 146
 147         settings = user.profile.settings
 148         settings.set_wksetting(FLATTR_AUTO, auto_flattr)
 149         settings.set_wksetting(FLATTR_MYGPO, flattr_mygpo)
 150         settings.set_wksetting(FLATTR_USERNAME, username)
 151         settings.save()
 152
 153         return HttpResponseRedirect(reverse('account') + '#flattr')
 154
 155
 156 class FlattrLogout(View):
 157     """ Removes Flattr authentication token """
 158
 159     def get(self, request):
 160         user = request.user
 161         settings = user.profile.settings
 162         settings.set_wksetting(FLATTR_AUTO, False)
 163         settings.set_wksetting(FLATTR_TOKEN, False)
 164         settings.set_wksetting(FLATTR_MYGPO, False)
 165         settings.save()
 166         return HttpResponseRedirect(reverse('account') + '#flattr')
 167
 168
 169 class FlattrTokenView(View):
 170     """ Callback for the Flattr authentication
 171
 172     Updates the user's Flattr token and redirects back to the account page """
 173
 174     def get(self, request):
 175
 176         user = request.user
 177         site = RequestSite(request)
 178         flattr = Flattr(user, site.domain, request.is_secure())
 179
 180         url = request.build_absolute_uri()
 181         token = flattr.process_retrieved_code(url)
 182         if token:
 183             messages.success(request, _('Authentication successful'))
 184             settings = user.profile.settings
 185             settings.set_wksetting(FLATTR_TOKEN, token)
 186             settings.save()
 187
 188         else:
 189             messages.error(request, _('Authentication failed. Try again later'))
 190
 191         return HttpResponseRedirect(reverse('account') + '#flattr')
 192
 193
 194 class AccountRemoveGoogle(View):
 195     """ Removes the connected Google account """
 196
 197     @method_decorator(login_required)
 198     def post(self, request):
 199         request.user.google_email = None
 200         request.user.save()
 201         messages.success(request, _('Your account has been disconnected'))
 202         return HttpResponseRedirect(reverse('account'))
 203
 204
 205 @login_required
 206 @never_cache
 207 @allowed_methods(['GET', 'POST'])
 208 def delete_account(request):
 209
 210     if request.method == 'GET':
 211         return render(request, 'delete_account.html')
 212
 213     user.is_active = False
 214     user.deleted = True
 215     user.save()
 216     logout(request)
 217     return render(request, 'deleted_account.html')
 218
 219
 220
 221 class DefaultPrivacySettings(View):
 222
 223     public = True
 224
 225     @method_decorator(login_required)
 226     @method_decorator(never_cache)
 227     def post(self, request):
 228         profile = request.user.profile
 229         profile.set_setting(PUBLIC_SUB_USER.name, self.public)
 230         profile.save()
 231         return HttpResponseRedirect(reverse('privacy'))
 232
 233
 234 class PodcastPrivacySettings(View):
 235
 236     public = True
 237
 238     @method_decorator(login_required)
 239     @method_decorator(never_cache)
 240     def post(self, request, podcast_id):
 241         podcast = Podcast.objects.get(id=podcast_id)
 242
 243         settings, created = UserSettings.objects.get_or_create(
 244             user=request.user,
 245             content_type=ContentType.objects.get_for_model(podcast),
 246             object_id=podcast.pk,
 247         )
 248
 249         settings.set_wksetting(PUBLIC_SUB_PODCAST, self.public)
 250         settings.save()
 251         return HttpResponseRedirect(reverse('privacy'))
 252
 253
 254 @login_required
 255 @never_cache
 256 def privacy(request):
 257     site = RequestSite(request)
 258     user = request.user
 259
 260     podcasts = Podcast.objects.filter(subscription__user=user)\
 261                               .distinct('pk')
 262     private = UserSettings.objects.get_private_podcasts(user)
 263
 264     subscriptions = []
 265     for podcast in podcasts:
 266
 267         subscriptions.append( (podcast, podcast in private) )
 268
 269     return render(request, 'privacy.html', {
 270         'private_subscriptions': not request.user.profile.settings.get_wksetting(PUBLIC_SUB_USER),
 271         'subscriptions': subscriptions,
 272         'domain': site.domain,
 273         })
 274
 275
 276 @vary_on_cookie
 277 @cache_control(private=True)
 278 @login_required
 279 def share(request):
 280     site = RequestSite(request)
 281
 282     user = request.user
 283
 284     if 'public_subscriptions' in request.GET:
 285         user.profile.subscriptions_token = ''
 286         user.profile.save()
 287
 288     elif 'private_subscriptions' in request.GET:
 289         user.profile.create_new_token('subscriptions_token')
 290         user.profile.save()
 291
 292     token = user.profile.get_token('subscriptions_token')
 293
 294     return render(request, 'share.html', {
 295         'site': site,
 296         'token': token,
 297         })