mygpo/users/views/settings.py

   1 from django.shortcuts import render, get_object_or_404
   2 from django.urls 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 gettext 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
  21 from mygpo.web.utils import normalize_twitter
  22 from mygpo.users.settings import PUBLIC_SUB_USER, PUBLIC_SUB_PODCAST
  23 from mygpo.users.models import UserProfile
  24
  25
  26 @login_required
  27 @vary_on_cookie
  28 @cache_control(private=True)
  29 @allowed_methods(["GET", "POST"])
  30 def account(request):
  31
  32     if request.method == "GET":
  33
  34         site = RequestSite(request)
  35         userpage_token = request.user.profile.get_token("userpage_token")
  36
  37         profile_form = ProfileForm(
  38             {
  39                 "twitter": request.user.profile.twitter,
  40                 "about": request.user.profile.about,
  41             }
  42         )
  43
  44         form = UserAccountForm(
  45             {
  46                 "email": request.user.email,
  47                 "public": request.user.profile.settings.get_wksetting(PUBLIC_SUB_USER),
  48             }
  49         )
  50
  51         return render(
  52             request,
  53             "account.html",
  54             {
  55                 "site": site,
  56                 "form": form,
  57                 "profile_form": profile_form,
  58                 "userpage_token": userpage_token,
  59             },
  60         )
  61
  62     try:
  63         form = UserAccountForm(request.POST)
  64
  65         if not form.is_valid():
  66             raise ValueError(
  67                 _(
  68                     "Oops! Something went wrong. Please double-check the data you entered."
  69                 )
  70             )
  71
  72         if form.cleaned_data["password_current"]:
  73             if not request.user.check_password(form.cleaned_data["password_current"]):
  74                 raise ValueError("Current password is incorrect")
  75
  76             request.user.set_password(form.cleaned_data["password1"])
  77
  78         request.user.email = form.cleaned_data["email"]
  79
  80         try:
  81             request.user.save()
  82         except Exception as ex:
  83             # TODO: which exception?
  84             messages.error(request, str(ex))
  85
  86         messages.success(request, "Account updated")
  87
  88     except (ValueError, ValidationError) as e:
  89         messages.error(request, str(e))
  90
  91     return render(request, "account.html", {"form": form})
  92
  93
  94 class ProfileView(View):
  95     """Updates the public profile and redirects back to the account view"""
  96
  97     def post(self, request):
  98         user = request.user
  99
 100         form = ProfileForm(request.POST)
 101
 102         if not form.is_valid():
 103             raise ValueError(
 104                 _(
 105                     "Oops! Something went wrong. Please double-check the data you entered."
 106                 )
 107             )
 108
 109         # Retrieve user profile for request associated user
 110         user_profile = get_object_or_404(UserProfile, user=request.user)
 111         user_profile.twitter = normalize_twitter(form.cleaned_data["twitter"])
 112         user_profile.about = strip_tags(form.cleaned_data["about"])
 113
 114         user_profile.save()
 115         messages.success(request, _("Data updated"))
 116
 117         return HttpResponseRedirect(reverse("account") + "#profile")
 118
 119
 120 class AccountRemoveGoogle(View):
 121     """Removes the connected Google account"""
 122
 123     @method_decorator(login_required)
 124     def post(self, request):
 125         request.user.google_email = None
 126         request.user.save()
 127         messages.success(request, _("Your account has been disconnected"))
 128         return HttpResponseRedirect(reverse("account"))
 129
 130
 131 @login_required
 132 @never_cache
 133 @allowed_methods(["GET", "POST"])
 134 def delete_account(request):
 135
 136     if request.method == "GET":
 137         return render(request, "delete_account.html")
 138
 139     user = request.user
 140     user.is_active = False
 141     user.save()
 142     logout(request)
 143     return render(request, "deleted_account.html")
 144
 145
 146 class DefaultPrivacySettings(View):
 147
 148     public = True
 149
 150     @method_decorator(login_required)
 151     @method_decorator(never_cache)
 152     def post(self, request):
 153         settings = request.user.profile.settings
 154         settings.set_setting(PUBLIC_SUB_USER.name, self.public)
 155         settings.save()
 156         return HttpResponseRedirect(reverse("privacy"))
 157
 158
 159 class PodcastPrivacySettings(View):
 160
 161     public = True
 162
 163     @method_decorator(login_required)
 164     @method_decorator(never_cache)
 165     def post(self, request, podcast_id):
 166         podcast = Podcast.objects.get(id=podcast_id)
 167
 168         settings, created = UserSettings.objects.get_or_create(
 169             user=request.user,
 170             content_type=ContentType.objects.get_for_model(podcast),
 171             object_id=podcast.pk,
 172         )
 173
 174         settings.set_wksetting(PUBLIC_SUB_PODCAST, self.public)
 175         settings.save()
 176         return HttpResponseRedirect(reverse("privacy"))
 177
 178
 179 @login_required
 180 @never_cache
 181 def privacy(request):
 182     site = RequestSite(request)
 183     user = request.user
 184
 185     podcasts = (
 186         Podcast.objects.filter(subscription__user=user)
 187         .distinct("pk")
 188         .prefetch_related("slugs")
 189     )
 190     private = UserSettings.objects.get_private_podcasts(user)
 191
 192     subscriptions = []
 193     for podcast in podcasts:
 194
 195         subscriptions.append((podcast, podcast in private))
 196
 197     return render(
 198         request,
 199         "privacy.html",
 200         {
 201             "private_subscriptions": not request.user.profile.settings.get_wksetting(
 202                 PUBLIC_SUB_USER
 203             ),
 204             "subscriptions": subscriptions,
 205             "domain": site.domain,
 206         },
 207     )
 208
 209
 210 @vary_on_cookie
 211 @cache_control(private=True)
 212 @login_required
 213 def share(request):
 214     site = RequestSite(request)
 215
 216     user = request.user
 217
 218     if "public_subscriptions" in request.GET:
 219         user.profile.subscriptions_token = ""
 220         user.profile.save()
 221
 222     elif "private_subscriptions" in request.GET:
 223         user.profile.create_new_token("subscriptions_token")
 224         user.profile.save()
 225
 226     token = user.profile.get_token("subscriptions_token")
 227
 228     return render(request, "share.html", {"site": site, "token": token})