contrib/waldo/models.py

   1 from django import forms
   2 from django.conf.urls.defaults import url, patterns, include
   3 from django.contrib import messages
   4 from django.contrib.auth import authenticate, login, views as auth_views
   5 from django.contrib.auth.forms import AuthenticationForm
   6 from django.contrib.auth.models import User
   7 from django.db import models
   8 from django.http import Http404, HttpResponseRedirect
   9 from django.shortcuts import render_to_response
  10 from django.utils.translation import ugettext_lazy, ugettext as _
  11 from django.views.decorators.cache import never_cache
  12 from django.views.decorators.csrf import csrf_protect
  13 from philo.models import MultiView, Page
  14
  15
  16 ERROR_MESSAGE = ugettext_lazy("Please enter a correct username and password. Note that both fields are case-sensitive.")
  17 LOGIN_FORM_KEY = 'this_is_the_login_form'
  18 LoginForm = type('LoginForm', (AuthenticationForm,), {
  19         LOGIN_FORM_KEY: forms.BooleanField(widget=forms.HiddenInput, initial=True)
  20 })
  21
  22
  23 def get_field_data(obj, fields):
  24         if fields == None:
  25                 fields = [field.name for field in obj._meta.fields if field.editable]
  26
  27         return dict([(field.name, field.value_from_object(obj)) for field in obj._meta.fields if field.name in fields])
  28
  29
  30 class LoginMultiView(MultiView):
  31         login_page = models.ForeignKey(Page, related_name='login_related')
  32
  33         @property
  34         def urlpatterns(self):
  35                 urlpatterns = patterns('',
  36                         url(r'^login/$', self.login, name='login'),
  37                         url(r'^logout/$', self.logout, name='logout')
  38                 )
  39                 return urlpatterns
  40
  41         def get_context(self, extra_dict=None):
  42                 context = {}
  43                 context.update(extra_dict or {})
  44                 return context
  45
  46         def display_login_page(self, request, message, node=None, extra_context=None):
  47                 request.session.set_test_cookie()
  48
  49                 redirect = request.META.get('HTTP_REFERER', None)
  50                 path = request.get_full_path()
  51                 if redirect != path:
  52                         if redirect is None:
  53                                 redirect = '/'.join(path.split('/')[:-2])
  54                         request.session['redirect'] = redirect
  55
  56                 if request.POST:
  57                         form = LoginForm(request.POST)
  58                 else:
  59                         form = LoginForm()
  60                 context = self.get_context({
  61                         'message': message,
  62                         'form': form
  63                 })
  64                 context.update(extra_context or {})
  65                 return self.login_page.render_to_response(node, request, extra_context=context)
  66
  67         def login(self, request, node=None, extra_context=None):
  68                 """
  69                 Displays the login form for the given HttpRequest.
  70                 """
  71                 context = self.get_context(extra_context)
  72
  73                 from django.contrib.auth.models import User
  74
  75                 # If this isn't already the login page, display it.
  76                 if not request.POST.has_key(LOGIN_FORM_KEY):
  77                         if request.POST:
  78                                 message = _("Please log in again, because your session has expired.")
  79                         else:
  80                                 message = ""
  81                         return self.display_login_page(request, message, node, context)
  82
  83                 # Check that the user accepts cookies.
  84                 if not request.session.test_cookie_worked():
  85                         message = _("Looks like your browser isn't configured to accept cookies. Please enable cookies, reload this page, and try again.")
  86                         return self.display_login_page(request, message, node, context)
  87                 else:
  88                         request.session.delete_test_cookie()
  89
  90                 # Check the password.
  91                 username = request.POST.get('username', None)
  92                 password = request.POST.get('password', None)
  93                 user = authenticate(username=username, password=password)
  94                 if user is None:
  95                         message = ERROR_MESSAGE
  96                         if username is not None and u'@' in username:
  97                                 # Mistakenly entered e-mail address instead of username? Look it up.
  98                                 try:
  99                                         user = User.objects.get(email=username)
 100                                 except (User.DoesNotExist, User.MultipleObjectsReturned):
 101                                         message = _("Usernames cannot contain the '@' character.")
 102                                 else:
 103                                         if user.check_password(password):
 104                                                 message = _("Your e-mail address is not your username."
 105                                                                         " Try '%s' instead.") % user.username
 106                                         else:
 107                                                 message = _("Usernames cannot contain the '@' character.")
 108                         return self.display_login_page(request, message, node, context)
 109
 110                 # The user data is correct; log in the user in and continue.
 111                 else:
 112                         if user.is_active:
 113                                 login(request, user)
 114                                 redirect = request.session.pop('redirect')
 115                                 return HttpResponseRedirect(redirect)
 116                         else:
 117                                 return self.display_login_page(request, ERROR_MESSAGE, node, context)
 118         login = never_cache(login)
 119
 120         def logout(self, request):
 121                 return auth_views.logout(request, request.META['HTTP_REFERER'])
 122
 123         def login_required(self, view):
 124                 def inner(request, node=None, *args, **kwargs):
 125                         if not request.user.is_authenticated():
 126                                 root_url = node.get_path(Site.objects.get_current().root_node).strip('/')
 127                                 login_url = reverse('login', urlconf=self).strip('/')
 128                                 return HttpResponseRedirect('/%s/%s/' % (root_url, login_url))
 129                         return view(request, node=node, *args, **kwargs)
 130
 131                 return inner
 132
 133         class Meta:
 134                 abstract = True
 135
 136
 137 class AccountMultiView(LoginMultiView):
 138         """
 139         Subclasses may define an account_profile model, fields from the User model
 140         to include in the account, and fields from the account profile to use in
 141         the account.
 142         """
 143         manage_account_page = models.ForeignKey(Page, related_name='classifieds_manage_account_page')
 144         user_fields = ['first_name', 'last_name', 'email']
 145         required_user_fields = user_fields
 146         account_profile = None
 147         account_profile_fields = None
 148
 149         @property
 150         def urlpatterns(self):
 151                 urlpatterns = super(AccountMultiView, self).urlpatterns
 152                 urlpatterns += patterns('',
 153                         url(r'^account/$', self.login_required(self.account_view), name='account')
 154                 )
 155                 return urlpatterns
 156
 157         def get_account_forms(self):
 158                 user_form = forms.models.modelform_factory(User, fields=self.user_fields)
 159
 160                 if self.account_profile is None:
 161                         profile_form = None
 162                 else:
 163                         profile_form = forms.models.modelform_factory(self.account_profile, fields=self.account_profile_fields or [field.name for field in self.account_profile._meta.fields if field.editable and field.name != 'user'])
 164
 165                 for field_name, field in user_form.base_fields.items():
 166                         if field_name in self.required_user_fields:
 167                                 field.required = True
 168                 return user_form, profile_form
 169
 170         def get_account_form_instances(self, user, data=None):
 171                 form_instances = []
 172                 user_form, profile_form = self.get_account_forms()
 173                 if data is None:
 174                         form_instances.append(user_form(instance=user))
 175                         if profile_form:
 176                                 form_instances.append(profile_form(instance=self.account_profile._default_manager.get_or_create(user=user)[0]))
 177                 else:
 178                         form_instances.append(user_form(data, instance=user))
 179                         if profile_form:
 180                                 form_instances.append(profile_form(data, instance=self.account_profile._default_manager.get_or_create(user=user)[0]))
 181
 182                 return form_instances
 183
 184         def account_view(self, request, node=None, extra_context=None):
 185                 if request.method == 'POST':
 186                         form_instances = self.get_account_form_instances(request.user, request.POST)
 187
 188                         for form in form_instances:
 189                                 if not form.is_valid():
 190                                         break
 191                         else:
 192                                 for form in form_instances:
 193                                         form.save()
 194                                 messages.add_message(request, messages.SUCCESS, "Account information saved.", fail_silently=True)
 195                                 return HttpResponseRedirect('')
 196                 else:
 197                         form_instances = self.get_account_form_instances(request.user)
 198
 199                 context = self.get_context({
 200                         'forms': form_instances
 201                 })
 202                 context.update(extra_context or {})
 203                 return self.manage_account_page.render_to_response(node, request, extra_context=context)
 204
 205         def has_valid_account(self, user):
 206                 user_form, profile_form = self.get_account_forms()
 207                 forms = []
 208                 forms.append(user_form(data=get_field_data(user, self.user_fields)))
 209
 210                 if profile_form is not None:
 211                         profile = self.account_profile._default_manager.get_or_create(user=user)[0]
 212                         forms.append(profile_form(data=get_field_data(profile, self.account_profile_fields)))
 213
 214                 for form in forms:
 215                         if not form.is_valid():
 216                                 return False
 217                 return True
 218
 219         def account_required(self, view):
 220                 def inner(request, *args, **kwargs):
 221                         if not self.has_valid_account(request.user):
 222                                 messages.add_message(request, messages.ERROR, "You need to add some account information before you can post listings.")
 223                                 return self.account_view(request, *args, **kwargs)
 224                         return view(request, *args, **kwargs)
 225
 226                 inner = self.login_required(inner)
 227                 return inner
 228
 229         class Meta:
 230                 abstract = True