本文整理汇总了Python中registration.backends.get_backend函数的典型用法代码示例。如果您正苦于以下问题:Python get_backend函数的具体用法?Python get_backend怎么用?Python get_backend使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了get_backend函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: moderate_list
def moderate_list(request, backend='default', template_name='registration/registration_moderate_list.html'):
backend = get_backend(backend)
profiles = backend.get_unmoderated_profiles(request)
return render(request, template_name, {
'profiles': profiles,
})
示例2: accept_email_invite
def accept_email_invite(request, activation_key):
inv = get_object_or_404 (Invitation, reg_activation_key=activation_key)
logging.debug("BBM: accept_email_invite view found invite %s." % str(inv))
if request.method == 'POST':
pw_form = EmailInviteAcceptForm(request.POST)
if pw_form.is_valid():
from registration.backends import get_backend
reg_backend = get_backend(settings.REGISTRATION_BACKEND)
u = reg_backend.activate(request, activation_key)
if not u:
logging.debug('BBM was unable to activate user with activation key %s' % (activation_key))
messages.error(request, 'Sorry we were unable to activate your user, please try again and contact us if the problem persists')
return HttpResponseRedirect(reverse('home'))
else:
logging.debug('BBM attempting to set password to %s for user %s' % (pw_form.data['password1'], u.username))
u.set_password(pw_form.data['password1'])
u.save()
#authenticate the user and log them in
auth_user = authenticate(username=u.email, password=pw_form.data['password1'])
if auth_user is not None:
logging.debug('BBM: new invited user %s authenticated' % auth_user.username)
#accept invite
inv.accept_invitation()
login(request, auth_user)
messages.info(request, "Thank you %s, your account has been activated and invitation accepted" % auth_user.first_name)
return HttpResponseRedirect(reverse('welcome'))
else:
messages.error(request, "Your username and/or password were not recognised, please try again.")
else:
pw_form=EmailInviteAcceptForm()
return render_to_response('groupmanager/accept_email_invite.html', {'invite': inv, 'pw_form': pw_form}, context_instance=RequestContext(request))
示例3: create
def create(self, request, **kwargs):
#print "@ create account"
self.method_check(request, allowed=['post'])
backend = get_backend('registration.backends.default.DefaultBackend')
postData = simplejson.loads(request.raw_post_data)
args = {'username':postData['username'],
'email' : postData['email'],
'password1' : postData['password']}
if User.objects.filter(email=postData['email']).count() > 0:
return self.create_response(request,{
'status': SYSTEM_ERROR,
'error': 'duplicate email'})
#print "post data"
#print args
#print "trying to create account"
newUser = backend.register(request,**args)
#print "user created"
if newUser:
return self.create_response(request,{'status': OK,
'message': 'Please check your email !!'})
else:
return self.create_response(request,{'status': SYSTEM_ERROR,
'error': 'Something is wrong >:/ '})
示例4: registerStudent
def registerStudent(request, backend, success_url=None, form_class=None,
disallowed_url='registration_disallowed',
template_name='registration/registration_form.html',
extra_context=None):
backend = get_backend(backend)
if not backend.registration_allowed(request):
return redirect(disallowed_url)
if form_class is None:
form_class = backend.get_form_class(request)
if request.method == 'POST':
form = form_class(data=request.POST, files=request.FILES)
if form.is_valid():
new_user = backend.register(request, **form.cleaned_data)
print new_user.first_name
if success_url is None:
to, args, kwargs = backend.post_registration_redirect(request, new_user)
return redirect(to, *args, **kwargs)
else:
return redirect(success_url)
else:
form = form_class()
if extra_context is None:
extra_context = {}
context = RequestContext(request)
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
return render_to_response(template_name,
{'form': form},
context_instance=context)
示例5: setup_and_activate
def setup_and_activate(request, activation_key, backend,
form_class=UserCreationForm,
template_name='registration/setup_new_user.html',
fail_template_name='registration/activate.html',
success_url=None):
backend = get_backend(backend)
profile = get_object_or_404(RegistrationProfile, activation_key=activation_key)
if not backend.can_activate(activation_key):
return render_to_response(fail_template_name,
context_instance=RequestContext(request))
if request.method == 'POST':
form = form_class(request.POST, request.FILES, instance=profile.user)
if form.is_valid():
form.save()
account = backend.activate(request, activation_key)
if success_url:
return redirect(success_url)
to, args, kwargs = backend.post_activation_redirect(request, account)
return redirect(to, *args, **kwargs)
else:
# do not prepopulate form with generated user data
form = form_class()
return render_to_response(template_name, {'form': form},
context_instance=RequestContext(request))
示例6: send_post_notification_email
def send_post_notification_email(post, event, request):
"""
Send blog post events notification email.
"""
# get the current site
if Site._meta.installed:
site = Site.objects.get_current()
else:
site = RequestSite(request)
subject = render_to_string(POST_EVENTS[event]['subject_template'], {
'site': site,
'post': post,
})
# no newlines
subject = ''.join(subject.splitlines())
message = render_to_string(POST_EVENTS[event]['email_template'], {
'site': site,
'post': post,
})
if POST_EVENTS[event]['receiver'] == 'moderators':
backend = get_backend('default')
moderators = (x[1] for x in backend.get_moderators(request))
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, moderators)
if POST_EVENTS[event]['receiver'] == 'author':
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, (post.author.email,))
示例7: register
def register(request, backend, success_url=None, form_class=None,
disallowed_url='registration_disallowed',
template_name='registration/registration_form.html',
extra_context=None):
backend = get_backend(backend)
if not backend.registration_allowed(request):
return redirect(disallowed_url)
if form_class is None:
form_class = backend.get_form_class(request)
if request.method == 'POST':
data = request.POST.copy() # so we can manipulate data
form = form_class(data, files=request.FILES)
if form.is_valid():
# random username
form.cleaned_data['username'] = ''.join([choice(letters) for i in xrange(30)])
new_user = backend.register(request, **form.cleaned_data)
if success_url is None:
to, args, kwargs = backend.post_registration_redirect(request, new_user)
return redirect(to, *args, **kwargs)
else:
return redirect(success_url)
else:
form = form_class()
if extra_context is None:
extra_context = {}
context = RequestContext(request)
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
return render_to_response(template_name,
{'form': form},
context_instance=context)
示例8: test_get_backend
def test_get_backend(self):
"""
Verify that ``get_backend()`` returns the correct value when
passed a valid backend.
"""
self.failUnless(isinstance(get_backend("registration.backends.default.DefaultBackend"), DefaultBackend))
示例9: _register_user
def _register_user(request, facebook, profile_callback=None):
"""
Creates a new user and authenticates
The registration form handles the registration and validation
Other data on the user profile is updates afterwards
"""
if not facebook.is_authenticated():
raise ValueError("Facebook needs to be authenticated for connect flows")
from registration.forms import RegistrationFormUniqueEmail
new_reg_module = True
try:
from registration.backends import get_backend
except ImportError:
new_reg_module = False
form_class = RegistrationFormUniqueEmail
facebook_data = facebook.facebook_registration_data()
data = request.POST.copy()
for k, v in facebook_data.items():
if not data.get(k):
data[k] = v
if request.REQUEST.get("force_registration_hard"):
data["email"] = data["email"].replace("@", "+%[email protected]" % randint(0, 100000))
form = form_class(data=data, files=request.FILES, initial={"ip": request.META["REMOTE_ADDR"]})
if not form.is_valid():
error = facebook_exceptions.IncompleteProfileError(
"Facebook data %s " "gave error %s" % (facebook_data, form.errors)
)
error.form = form
raise error
if new_reg_module:
# support for the newer implementation
try:
from django.conf import settings
backend = get_backend(settings.REGISTRATION_BACKEND)
except:
raise ValueError("Cannot get django-registration backend from " "settings.REGISTRATION_BACKEND")
new_user = backend.register(request, **form.cleaned_data)
else:
new_user = form.save(profile_callback=profile_callback)
# update some extra data not yet done by the form
new_user = _update_user(new_user, facebook)
# IS this the correct way for django 1.3? seems to require the backend
# attribute for some reason
new_user.backend = "django_facebook.auth_backends.FacebookBackend"
auth.login(request, new_user)
return new_user
示例10: invite_email
def invite_email(request, group_id):
"""
just a wrapper for emailregiatration backend register view which is a clone of the default registration backend
but extended to add new users into the appropriate group.
"""
#TODO: currently supports 1 email invite at a time need to make multiple
#TODO: capture email text in invite message in when it is editable
g = get_object_or_404(Group, pk=group_id)
if request.method == 'POST':
if g.is_organiser(request.user) or (g.is_member(request.user) and g.is_mem_get_mem) or g.is_open: #check we are the organiser or the group allows others to invite
next_url=request.POST.get('next', None) #establish where to go next from a next field in the submitted form
logging.debug("GM: attempting to invite a new email invited member and add to group %s then redirect to %s" % (g.name,next_url))
user_form = EmailInvitationForm(request.POST)
#check if this person already exists as a user. If so just invite them.
if user_form.is_valid():
try:
logging.debug("GM: testing duplicate user by email address %s" % (user_form.data['email']))
u = User.objects.filter(email=user_form.data['email'])
except ObjectDoesNotExist:
from registration.backends import get_backend
backend = get_backend('emailregistration.backends.registration.InviteEmailRegBackend') #use custom invite backend to send invitation emails
#create a new inactive user and send them an activation email
u = backend.register(request, **user_form.cleaned_data)
messages.info(request, 'Sucessfully invited %s at address %s to join this group.' % (user_form.data['first_name'], user_form.data['email']))
#get the activation key from the new inactive user registration profile to put in the invite as a reference
from registration.models import RegistrationProfile
p = RegistrationProfile.objects.get(user=u)
#create the invitation in the db
inv = Invitation.objects.create(group_id=g.id, inviter_id=request.user.id, invitee_id=u.id, reg_activation_key=p.activation_key)
logging.debug("RM: create invite to group %s from %s to %s" % (g.id, request.user.id, u.id))
else: #user already exists (by email) so create the invitation in the db no new user no activation key
inv = Invitation.objects.create(group_id=g.id, inviter_id=request.user.id, invitee_id=u.id, reg_activation_key='existing user invited')
messages.info(request, '%s at address %s is already a user of %s and will receive an invitation to joint this group.' % (u.first_name, u.email, settings.SITE_NAME))
logging.debug("RM: create invite to group %s from %s to %s" % (g.id, request.user.id, u.id))
#TODO: notify them of the new invite by email
else: #invalid form re-render the template, show form errors
logging.debug("GM: Failed to add new email invite user to group %s because posted form was invalid." % (g.name))
return render_to_response("groupmanager/invite_email_form.html",{'group_id': group_id, 'form':user_form },context_instance=RequestContext(request))
if settings.AUTO_ACCEPT: #automatically accept the invite (ie. don't wait for the invitee to do so)
inv.accept_invitation()
else: #user doesn't have permission to invite into the group
logging.error("GM: invite_email_member received request to invite users from user without correct permissions.")
messages.error(request, 'You do not have permission to invite users to that group. If this problem persists please let us know.')
else: #its a GET so just render the template
user_form = EmailInvitationForm()
return render_to_response("groupmanager/invite_email_form.html",{'group_id': group_id, 'form':user_form },context_instance=RequestContext(request))
if next_url:
return HttpResponseRedirect(next_url)
return HttpResponseRedirect(reverse('group_home', args=[g.id]))
示例11: get
def get(self, request, backend, *args, **kwargs):
backend = get_backend(backend)
account = backend.activate(request, **kwargs)
if account or request.user.is_authenticated():
return redirect(settings.LOGIN_REDIRECT_URL)
else:
# ошибка активации
context = RequestContext(request)
return self.render_to_response(context)
示例12: register_test_cookie
def register_test_cookie(request, backend, success_url=None, form_class=None,
disallowed_url='registration_disallowed',
template_name='registration/registration_form.html',
extra_context=None):
"""
Регистрация пользователя.
Создано основе стандартного представления register из django-registration
путем добавления в начале проверки включенности cookies в браузере,
и фокусов с формой в зависимости от статуса регистрирующегося.
"""
if request.method == 'POST':
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
else:
return TemplateResponse(request, 'cookies.html')
request.session.set_test_cookie()
backend = get_backend(backend)
if not backend.registration_allowed(request):
return redirect(disallowed_url)
if request.method == 'POST':
status = int(request.POST.get("status", u"0"))
if status == 1: # интересующийся гражданин.
form = RegistrationFormShort(data=request.POST,
files=request.FILES)
else: # представитель организации.
form = RegistrationFormFull(data=request.POST, files=request.FILES)
if form.is_valid():
new_user = backend.register(request, **form.cleaned_data)
if success_url is None:
to, args, kwargs = backend.post_registration_redirect(request,
new_user)
return redirect(to, *args, **kwargs)
else:
return redirect(success_url)
else:
if status == 1:
form = RegistrationFormFull(data=request.POST,
files=request.FILES)
else:
form = RegistrationFormFull()
if extra_context is None:
extra_context = {}
extra_context.update({'required_error':
Field.default_error_messages['required']})
context = {'form': form}
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
return TemplateResponse(request, template_name, context)
示例13: _register_user
def _register_user(request, facebook, profile_callback=None):
if not facebook.is_authenticated():
raise ValueError, 'Facebook needs to be authenticated for connect flows'
from registration.forms import RegistrationFormUniqueEmail
import registration
new_reg_module = hasattr(registration, 'backends')
if new_reg_module:
from registration.backends import get_backend
form_class = RegistrationFormUniqueEmail
facebook_data = facebook.facebook_registration_data()
data = request.POST.copy()
for k, v in facebook_data.items():
if not data.get(k):
data[k] = v
if request.REQUEST.get('force_registration_hard'):
data['email'] = data['email'].replace('@', '+%[email protected]' % randint(0, 100000))
form = form_class(data=data, files=request.FILES,
initial={'ip': request.META['REMOTE_ADDR']})
if not form.is_valid():
error = facebook_exceptions.IncompleteProfileError('Facebook data %s gave error %s' % (facebook_data, form.errors))
error.form = form
raise error
if new_reg_module:
#support for the newer implementation
try:
from django.conf import settings
backend = get_backend(settings.REGISTRATION_BACKEND)
except:
raise ValueError, 'Cannot get django-registration backend from settings.REGISTRATION_BACKEND'
new_user = backend.register(request, **form.cleaned_data)
else:
new_user = form.save(profile_callback=profile_callback)
profile = new_user.get_profile()
profile.date_of_birth = facebook_data.get('date_of_birth')
if hasattr(profile, 'raw_data'):
serialized_fb_data = json.dumps(facebook.facebook_profile_data())
profile.raw_data = serialized_fb_data
profile.save()
auth.login(request, new_user)
return new_user
示例14: login
def login(request):
error_messages = []
#grab the redirect URL if set
redirect = request.GET.get('next') or request.POST.get('redirect', '')
#Create login and registration forms
login_form = SigninForm()
registration_form = CreateAccountForm()
if request.method == 'POST':
#Existing user is logging in
if request.POST.has_key('login'):
login_form = SigninForm(data=request.POST)
if login_form.is_valid():
user = auth.authenticate(username=request.POST['user_or_email'], password=request.POST['password'])
#Log in
auth.login(request, user)
#set session timeout
if request.POST.has_key('remember_me'):
request.session.set_expiry(settings.SESSION_TIMEOUT)
if redirect:
return HttpResponseRedirect(redirect)
else:
return HttpResponseRedirect(reverse('frontpage'))
#New user is registering
elif request.POST.has_key('register'):
registration_form = CreateAccountForm(data=request.POST)
if registration_form.is_valid():
backend = get_backend(settings.REGISTRATION_BACKEND)
new_user = backend.register(request, **registration_form.cleaned_data)
#sign straight in
signed_in_user = auth.authenticate(username=request.POST['username'], password=request.POST['password1'])
auth.login(request, signed_in_user)
#redirect
if redirect:
return HttpResponseRedirect(redirect)
else:
return HttpResponseRedirect(reverse('frontpage'))
return render_to_response('registration/extended_login.html', {'registration_form': registration_form,
'login_form': login_form,
'error_messages': error_messages,
'redirect': redirect}, context_instance = RequestContext(request))
示例15: get
def get(self, request, backend, template_name=None, success_url=None, form_class=None,
disallowed_url='registration_disallowed', extra_context=None):
if template_name is not None:
self.template_name = template_name
backend = get_backend(backend)
if not backend.registration_allowed(request):
return redirect(disallowed_url)
if form_class is None:
form_class = backend.get_form_class(request)
form = form_class()
context = self._add_extra_context(request, form, extra_context)
return self.render_to_response(context)