# -*- 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 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 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')