mygpo/users/views/settings.py

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