You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
292 lines
11 KiB
292 lines
11 KiB
# -*- coding: utf-8 -*-
|
|
from django.conf import settings
|
|
from django.contrib.sites.models import RequestSite
|
|
from django.contrib.sites.models import Site
|
|
from django.utils.translation import ugettext as _
|
|
|
|
from registration import signals
|
|
from registration.models import RegistrationProfile
|
|
from registration.views import ActivationView as BaseActivationView
|
|
from registration.views import RegistrationView as BaseRegistrationView
|
|
|
|
|
|
import json
|
|
|
|
class RegistrationView(BaseRegistrationView):
|
|
"""
|
|
A registration backend which follows a simple workflow:
|
|
|
|
1. User signs up, inactive account is created.
|
|
|
|
2. Email is sent to user with activation link.
|
|
|
|
3. User clicks activation link, account is now active.
|
|
|
|
Using this backend requires that
|
|
|
|
* ``registration`` be listed in the ``INSTALLED_APPS`` setting
|
|
(since this backend makes use of models defined in this
|
|
application).
|
|
|
|
* The setting ``ACCOUNT_ACTIVATION_DAYS`` be supplied, specifying
|
|
(as an integer) the number of days from registration during
|
|
which a user may activate their account (after that period
|
|
expires, activation will be disallowed).
|
|
|
|
* The creation of the templates
|
|
``registration/activation_email_subject.txt`` and
|
|
``registration/activation_email.html``, which will be used for
|
|
the activation email. See the notes for this backends
|
|
``register`` method for details regarding these templates.
|
|
|
|
Additionally, registration can be temporarily closed by adding the
|
|
setting ``REGISTRATION_OPEN`` and setting it to
|
|
``False``. Omitting this setting, or setting it to ``True``, will
|
|
be interpreted as meaning that registration is currently open and
|
|
permitted.
|
|
|
|
Internally, this is accomplished via storing an activation key in
|
|
an instance of ``registration.models.RegistrationProfile``. See
|
|
that model and its custom manager for full documentation of its
|
|
fields and supported operations.
|
|
|
|
"""
|
|
def register(self, request, **cleaned_data):
|
|
"""
|
|
Given a username, email address and password, register a new
|
|
user account, which will initially be inactive.
|
|
|
|
Along with the new ``User`` object, a new
|
|
``registration.models.RegistrationProfile`` will be created,
|
|
tied to that ``User``, containing the activation key which
|
|
will be used for this account.
|
|
|
|
An email will be sent to the supplied email address; this
|
|
email should contain an activation link. The email will be
|
|
rendered using two templates. See the documentation for
|
|
``RegistrationProfile.send_activation_email()`` for
|
|
information about these templates and the contexts provided to
|
|
them.
|
|
|
|
After the ``User`` and ``RegistrationProfile`` are created and
|
|
the activation email is sent, the signal
|
|
``registration.signals.user_registered`` will be sent, with
|
|
the new ``User`` as the keyword argument ``user`` and the
|
|
class of this backend as the sender.
|
|
|
|
"""
|
|
first_name, last_name, email, password = cleaned_data['first_name'],cleaned_data['last_name'], cleaned_data['email'], cleaned_data['password1']
|
|
if Site._meta.installed:
|
|
site = Site.objects.get_current()
|
|
else:
|
|
site = RequestSite(request)
|
|
new_user = RegistrationProfile.objects.create_inactive_user(first_name, last_name, email,
|
|
password, site)
|
|
signals.user_registered.send(sender=self.__class__,
|
|
user=new_user,
|
|
request=request)
|
|
|
|
return new_user
|
|
|
|
def registration_allowed(self, request):
|
|
"""
|
|
Indicate whether account registration is currently permitted,
|
|
based on the value of the setting ``REGISTRATION_OPEN``. This
|
|
is determined as follows:
|
|
|
|
* If ``REGISTRATION_OPEN`` is not specified in settings, or is
|
|
set to ``True``, registration is permitted.
|
|
|
|
* If ``REGISTRATION_OPEN`` is both specified and set to
|
|
``False``, registration is not permitted.
|
|
|
|
"""
|
|
return getattr(settings, 'REGISTRATION_OPEN', True)
|
|
|
|
|
|
def get_success_url(self, request, user):
|
|
"""
|
|
Return the name of the URL to redirect to after successful
|
|
user registration.
|
|
|
|
"""
|
|
# return json.dumps({'bla': 'ok'})
|
|
return ('registration_complete', (), {})
|
|
|
|
|
|
|
|
class ActivationView(BaseActivationView):
|
|
def activate(self, request, activation_key):
|
|
"""
|
|
Given an an activation key, look up and activate the user
|
|
account corresponding to that key (if possible).
|
|
|
|
After successful activation, the signal
|
|
``registration.signals.user_activated`` will be sent, with the
|
|
newly activated ``User`` as the keyword argument ``user`` and
|
|
the class of this backend as the sender.
|
|
|
|
"""
|
|
activated_user = RegistrationProfile.objects.activate_user(activation_key)
|
|
if activated_user:
|
|
|
|
signals.user_activated.send(sender=self.__class__,
|
|
user=activated_user,
|
|
request=request)
|
|
activated_user.backend = 'django.contrib.auth.backends.ModelBackend'
|
|
login(request, activated_user)
|
|
|
|
return activated_user
|
|
|
|
def get_success_url(self, request, user):
|
|
return ('registration_activation_complete', (), {})
|
|
|
|
|
|
|
|
|
|
|
|
from django.http import HttpResponse, HttpResponseRedirect
|
|
|
|
from accounts.models import User
|
|
|
|
from registration.forms import RegistrationFormUniqueEmail
|
|
from django.contrib.auth import login, logout
|
|
|
|
from django.views.decorators.debug import sensitive_post_parameters
|
|
from django.views.decorators.cache import never_cache
|
|
|
|
@sensitive_post_parameters('password1', 'password2')
|
|
@never_cache
|
|
def RegisterAjaxView(request):
|
|
#if request.is_ajax():
|
|
data = {'success': False}
|
|
if request.POST:
|
|
form = RegistrationFormUniqueEmail(request.POST)
|
|
if form.is_valid():
|
|
first_name, last_name, email, password = form.cleaned_data['first_name'],\
|
|
form.cleaned_data['last_name'], form.cleaned_data['email'],\
|
|
form.cleaned_data['password1']
|
|
if Site._meta.installed:
|
|
site = Site.objects.get_current()
|
|
else:
|
|
site = RequestSite(request)
|
|
new_user = RegistrationProfile.objects.create_inactive_user(first_name, last_name, email,
|
|
password, site)
|
|
signals.user_registered.send(sender=User,
|
|
user=new_user,
|
|
request=request)
|
|
data['success'] = True
|
|
|
|
else:
|
|
data.update({'errors':form.errors})
|
|
|
|
return HttpResponse(json.dumps(data), content_type='application/json')
|
|
else:
|
|
# 404
|
|
return HttpResponse('not post')
|
|
#else:
|
|
# 404
|
|
# return HttpResponse('not ajax')
|
|
|
|
def RegisterReply(request):
|
|
if request.GET:
|
|
email = request.GET['email']
|
|
try:
|
|
user = User.objects.get(username=email)
|
|
except User.DoesNotExist:
|
|
response = {'errors': {'email': _(u'Пользователя с таким email не существует')}}
|
|
return HttpResponse(json.dumps(response), content_type='application/json')
|
|
if user.is_active:
|
|
response = {'errors': {'email': _(u'Пользователя с таким email уже активирован')}}
|
|
return HttpResponse(json.dumps(response), content_type='application/json')
|
|
else:
|
|
try:
|
|
registration_profile = user.registrationprofile_set.all()[0]
|
|
except IndexError:
|
|
registration_profile = RegistrationProfile.create_profile(user)
|
|
if Site._meta.installed:
|
|
site = Site.objects.get_current()
|
|
else:
|
|
site = RequestSite(request)
|
|
registration_profile.send_activation_email(site)
|
|
response = {'success': True}
|
|
return HttpResponse(json.dumps(response), content_type='application/json')
|
|
|
|
|
|
else:
|
|
return HttpResponse('no data')
|
|
|
|
|
|
from django.contrib.auth.forms import AuthenticationForm
|
|
from registration.forms import LoginForm
|
|
|
|
|
|
def LogoutView(request):
|
|
logout(request)
|
|
return HttpResponseRedirect(request.META.get('HTTP_REFERER','/'))
|
|
|
|
@sensitive_post_parameters('password')
|
|
def LoginView(request):
|
|
if request.POST:
|
|
|
|
form = LoginForm(data=request.POST)
|
|
#return HttpResponse(form.username)
|
|
|
|
|
|
if form.is_valid():
|
|
login(request, form.get_user())
|
|
response= {'success':True}
|
|
return HttpResponse(json.dumps(response), content_type='application/json')
|
|
#return HttpResponseRedirect(request.META.get('HTTP_REFERER','/'))
|
|
else:
|
|
response={'success':False, 'errors': form.errors}
|
|
if getattr(form, 'inactive', None):
|
|
response.update({'inactive': True})
|
|
|
|
return HttpResponse(json.dumps(response), content_type='application/json')
|
|
|
|
else:
|
|
HttpResponseRedirect('/')
|
|
|
|
from accounts.forms import RegistrationCompleteForm, RecoveryForm
|
|
from django.shortcuts import render
|
|
|
|
|
|
def complete_registration(request):
|
|
if request.is_ajax():
|
|
response = {'success': False}
|
|
form = RegistrationCompleteForm(request.POST, instance=request.user)
|
|
if form.is_valid():
|
|
user = form.save()
|
|
response['success']=True
|
|
response['redirect'] = user.get_permanent_url()
|
|
else:
|
|
response['errors'] = form.errors
|
|
return HttpResponse(json.dumps(response), content_type='application/json')
|
|
|
|
else:
|
|
return HttpResponse('not ajax')
|
|
|
|
def acquire_email(request, template_name="registration/acquire_email.html"):
|
|
"""
|
|
Request email for the create user flow for logins that don't specify their email address.
|
|
"""
|
|
backend = request.session['partial_pipeline']['backend']
|
|
return render(request, template_name, {"backend": backend})
|
|
|
|
|
|
def pswd_recovery(request):
|
|
#if request.is_ajax():
|
|
response = {'success': False}
|
|
form = RecoveryForm(request.POST)
|
|
if form.is_valid():
|
|
user = form.get_user()
|
|
user.se
|
|
response['success']=True
|
|
else:
|
|
response['errors'] = form.errors
|
|
return HttpResponse(json.dumps(response), content_type='application/json')
|
|
|
|
#else:
|
|
# return HttpResponse('not ajax')
|
|
|
|
|