def register(request, disallowed_url='registration_disallowed', template_name='registration/registration.html'): """用户注册 """ # 是否允许用户进行注册 allow_register = getattr(settings, 'REGISTRATION_OPEN', False) if not allow_register: return redirect(disallowed_url) if request.method == 'POST': form = RegistrationForm(request.POST) # 数据验证 if form.is_valid(): username = form.cleaned_data['username'] email = form.cleaned_data['email'] password = form.cleaned_data['password1'] # 创建一个未激活的用户和默认的扩展属性 act_key = TeamProfile.objects.create_inactive_user(username, email, password) # 直接将激活码作为链接发给用户 to, args, kwargs = ('registration_activate',(), {'activation_key':act_key}) return redirect(to, *args, **kwargs) else: form = RegistrationForm() context = RequestContext(request) return render_to_response(template_name, {'form': form}, context_instance=context)
def register(request, template_name='registration/register.html'): profile_url = settings.USER_PROFILE_URL % 'username' if request.method == 'GET': form = RegistrationForm() else: # POST form = RegistrationForm(data=request.POST) if form.is_valid(): hn_username = form.cleaned_data['hn_username'] # user_data is a dict containing the users HN account creation # date, karma at query time, and HN profile user_data = retrieve_hn_user_data(hn_username) # form validation checks that hn_username matches what's provided # and that the "key" (a url) is in the profile temp_password = ''.join(random.sample(string.letters, 16)) new_user = User.objects.create_user(username=hn_username, email='', password=temp_password) user = authenticate(username=new_user.username, password=temp_password) if user is not None: login(request, user) messages.success(request, 'That worked. Please provide a password.') return HttpResponseRedirect(reverse('set_password')) return render_to_response(template_name, locals(), context_instance=RequestContext(request))
def register(request): if request.user.is_authenticated(): return redirect('current_profile') if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): username = form.cleaned_data['username'] password = form.cleaned_data['password1'] #new_user = RegistrationProfile.objects.create_inactive_user(username, email, password) #return redirect('registration_complete') user = User.objects.create_user(username, form.cleaned_data['email'], password) user.first_name = form.cleaned_data['first_name'] user.last_name = form.cleaned_data['last_name'] user.save() user = auth.authenticate(username=username, password=password) assert user and user.is_authenticated() auth.login(request, user) # TODO: redirect to a message with confirmation return redirect(user.get_absolute_url()) else: form = RegistrationForm() return render_to_response('users/register.html', context_instance=RequestContext(request, {'form': form}))
def create_account(request): if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): user = User.objects.create_user( form.cleaned_data['email'], form.cleaned_data['email'], form.cleaned_data['password'], ) user.first_name = form.cleaned_data['first_name'] user.last_name = form.cleaned_data['last_name'] user.save() # Log in the new user. Note that Django requires that we call # authenticate() despite its apparent redundancy in this case user = authenticate(username=user.username, password=form.cleaned_data['password']) login(request, user) return redirect(reverse('registration.views.create_account_done')) else: form = RegistrationForm() return render_to_response('registration/create_account.html', RequestContext(request, { 'form': form, }))
def handle_post(self, request): """ Registers a user if it was a request to register a user and the registration form was correctly completed. """ # Confirm that the requst is a post, and that this form is # the intended recipient of the posted data. if not request.POST or self.submit_btn_name() not in request.POST: return None form = RegistrationForm(request.POST, auto_id=False) if form.is_valid(): # Create a user, log them in, and redirect based on the # success_url rules. user, created = User.objects.create_user(request=request, send_email=True, **form.cleaned_data) user_cache = authenticate( username=form.cleaned_data['email'], password=form.cleaned_data['password1']) expire_login(request, user_cache) response = HttpResponseRedirect(success_url(request)) response.set_cookie('myguid', user.user_guid, expires=365*24*60*60, domain='.my.jobs') return response return None
def register(request, extra_context=None): if not getattr(settings, 'REGISTRATION_OPEN', True): return redirect('registration_disallowed') if request.method == 'POST': form = RegistrationForm(data=request.POST, files=request.FILES) if form.is_valid(): username, email, password = form.cleaned_data['username'], form.cleaned_data['email'], form.cleaned_data['password1'] site = Site.objects.get_current() if Site._meta.installed else RequestSite(request) new_user = RegistrationProfile.objects.create_inactive_user(username, email, password, site) signals.user_registered.send(sender=None, user=new_user, request=request) profile = UserProfile.objects.get(user=new_user) seller_type = form.cleaned_data['seller_type'] phone = form.cleaned_data['phone'] profile.seller_type = seller_type profile.phone = phone profile.save() gravatar_task.delay(new_user, new_user.pk) success_url = request.GET.get('next','') if success_url: return redirect(success_url) else: return redirect('registration_complete') else: form = RegistrationForm() 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('static_pages/index.html', {'register_form': form}, context_instance=context)
def register(request): if request.user.is_authenticated(): return HttpResponseRedirect('/profile/') if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): user = User.objects.create_user(username=form.cleaned_data['username'], email = form.cleaned_data['email'], password=form.cleaned_data['password']) user.save() registration = UserProfile(user=user, name = form.cleaned_data['name'], address = form.cleaned_data['address'], contact = form.cleaned_data['contact'], stream = form.cleaned_data['stream'], age = form.cleaned_data['age'], gender = form.cleaned_data['gender'], register_as = form.cleaned_data['register_as'] ) if form.cleaned_data['register_as']=='FY': facstat = FacultyStatus(username = form.cleaned_data['username'], name = form.cleaned_data['name']) facstat.save() if 'picture' in request.FILES: registration.picture = request.FILES['picture'] registration.save() return HttpResponseRedirect('/profile') else: return render_to_response('registration/register.html',{'form':form, 're':"active"}, context_instance=RequestContext(request)) else: form = RegistrationForm() context = {'form': form, 're':"active"} return render_to_response('registration/register.html', context, context_instance=RequestContext(request))
def register(request): if not request.user.is_anonymous(): return redirect('/home/') if request.method == 'POST': title = "Update Profile" form = RegistrationForm(request.POST) if form.is_valid(): email = form.cleaned_data['email'] password = form.cleaned_data['password1'] user = User.objects.create(username=email_to_username(email), email=email) user.set_password(password) user.save() account = Account.objects.create( user=user, first_name=form.cleaned_data['first_name'], middle_name=form.cleaned_data['middle_name'], last_name=form.cleaned_data['last_name'], mobile_no=form.cleaned_data['phone_number'], email=form.cleaned_data['email'] ) return redirect('/register/success/') else: title = "Create New Profile" form = RegistrationForm() return render( request, 'registration/register.html', {'form': form, 'title': title} )
def edit(request): curr_user = request.user if request.method == 'POST': form = RegistrationForm(request.POST, user=curr_user) if form.is_valid(): try: curr_user.account.first_name = form.cleaned_data['first_name'] curr_user.account.middle_name = form.cleaned_data['middle_name'] curr_user.account.last_name = form.cleaned_data['last_name'] curr_user.account.mobile_no = form.cleaned_data['phone_number'] #curr_user.account.email = form.cleaned_data['email'] curr_user.account.save() except Account.DoesNotExist: return HttpResponse('The Account object does not exist for this user') return redirect('/register/success/') else: form = RegistrationForm(user=curr_user) return render( request, 'registration/register.html', {'form': form, 'title': 'Update Profile'} )
def handle_post(self, request): """ Registers a user if it was a request to register a user and the registration form was correctly completed. """ # Confirm that the requst is a post, and that this form is # the intended recipient of the posted data. if not request.POST or self.submit_btn_name() not in request.POST: return None form = RegistrationForm(request.POST, auto_id=False) if form.is_valid(): # Create a user, log them in, and redirect based on the # success_url rules. user, created = User.objects.create_user(request=request, send_email=True, **form.cleaned_data) user_cache = authenticate(username=form.cleaned_data['email'], password=form.cleaned_data['password1']) expire_login(request, user_cache) response = HttpResponseRedirect(success_url(request)) response.set_cookie('myguid', user.user_guid, expires=365 * 24 * 60 * 60, domain='.my.jobs') return response return None
def user_profile_post(request, **kwargs): user=request.user form=RegistrationForm(request.POST) added_context={'registration_form': form} if not form.is_valid(user=user): form.reformat_errors() # log.debug('user %r not valid, aborting' % user.contributor) return render(request, 'registration/user_profile.html', added_context) user.first_name=form.cleaned_data['first_name'] user.last_name=form.cleaned_data['last_name'] user.email=form.cleaned_data['email'] user.password=make_password(form.cleaned_data['password1']) user.contributor.lab.name=form.cleaned_data['lab'] user.contributor.lab.url=form.cleaned_data['lab_url'] try: # log.debug('about to save user: %r' % user.contributor) user.save() added_context['msgs']='Profile successfully updated' except Exception as e: msgs='Unable to save user information: %s' % e added_context['msgs']=msgs # log.debug(msgs) return render(request, 'registration/user_profile.html', added_context)
def login(request): if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): return HttpResponseRedirect('') else: return render(request, 'registration/login.html')
def __init__(self, *args, **kwargs): user_profile_instance = kwargs.pop('user_profile_instance', None) captcha_answer = kwargs.pop('captcha_answer', None) RegistrationForm.__init__(self, captcha_answer=captcha_answer, *args, **kwargs) ArtistProfileUpdateForm.__init__(self, user_profile_instance=user_profile_instance, *args, **kwargs) # Move CAPTCHA and EULA fields to the end self.fields.keyOrder.remove('captcha') self.fields.keyOrder.remove('over13') self.fields.keyOrder.remove('accept_eula') self.fields.keyOrder.extend(['captcha', 'over13', 'accept_eula'])
def createUser(request): if request.method == 'POST': # If the form has been submitted... form = RegistrationForm(request.POST) # A form bound to the POST data if form.is_valid(): # All validation rules pass try: form.save() except ValidationError, err: error = unicode(err) return render(request, 'createuser.html', {'form': form, 'error': error}) return HttpResponseRedirect('/thanks/') # Redirect after POST
def register(request): if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): user = form.save() return redirect('registration_completed') else: form = RegistrationForm() return TemplateResponse(request, 'registration/register.html', {'form': form})
def login_register(request): form = None next_url = None if request.method == 'POST': action = request.POST.get('action') next_url = request.GET.get('next') or reverse('login') if action == 'login': username = request.POST.get('username', '') password = request.POST.get('password1', '') if username and password: user = authenticate(username=username, password=password) if user is not None: login(request, user) return redirect(next_url) # Could not authenticate form = { 'username': { 'errors': 'Your username and password did not match.', } } else: form = { 'password1': { 'errors': 'Please enter a username and password.', }, } elif action == 'register': form = RegistrationForm(request.POST) if form.is_valid(): username = form.cleaned_data['username'] email = form.cleaned_data['email'] password = form.cleaned_data['password1'] User.objects.create_user(username, email, password) user = authenticate(username=username, password=password) login(request, user) return redirect(next_url) else: # The action is not set. Malicious submission? pass context = { 'next_url': next_url, 'form': form, } return render(request, 'login.djhtml', context)
def _register_all(trial_run, email_func): if trial_run: def trial_email(subject, body, from_, addresses, fail_silently): print "-" * 60 print "Would send this mail:" print "To: %s" % ", ".join(addresses) print "From: %s" % from_ print "Subject: %s" % subject print print body print '-' * 60 email_func = trial_email anon_racks = Rack.objects.filter(user=u'') addrs = set([rack.email.strip() for rack in anon_racks]) names_seen = set() current_site = Site.objects.get(id=settings.SITE_ID) for email in addrs: name = email.split('@', 1)[0] import re name = re.sub(r'[^!A-Za-z0-9_-]', '_', name) if name in names_seen: raise ValueError("Oh crap, already saw name %r" % name) names_seen.add(name) password = randpass() # Just so we always have a non-empty password. data = {'username': name, 'email': email, 'password1': password, 'password2': password,} template_args = {'name': name, 'email': email, 'domain': current_site.domain, 'password': password, 'activation_days': settings.ACCOUNT_ACTIVATION_DAYS, } form = RegistrationForm(data=data) if form.is_valid(): # Register an inactive account and get the key. template = register_email_txt user = form.save() reg_profile = RegistrationProfile.objects.filter(user=user)[0] template_args['key'] = reg_profile.activation_key # We also need to provide a way to set your password. template_args['password_reset_token'] = default_token_generator.make_token(user) template_args['uidb36'] = int_to_base36(user.id) if trial_run: user.delete(); reg_profile.delete() else: if form.errors.get('username', [''])[0].count(u'already taken'): # Send an email without the link to the predetermined username. template = register_email_name_taken_txt else: print "Problem with address %s:" % email import pprint pprint.pprint(form.errors) continue send_email(template, trial_run, email_func=email_func, **template_args)
def login(request): #grab the redirect URL if set if request.POST.get('next'): redirect = request.POST.get('next') elif request.POST.get('redirect'): redirect = request.POST.get('redirect') elif request.GET.get('next'): redirect = request.GET.get('next') else: redirect = request.META.get('HTTP_REFERER', '/') if redirect.endswith("login"): redirect = "/myaccount" login_form = AuthenticationForm() registration_form = RegistrationForm() if request.POST: login_form = AuthenticationForm(request.POST) registration_form = RegistrationForm(request.POST) username = request.POST.get('username', None) password = request.POST.get('password', None) user = auth.authenticate(username=username, password=password) if user is not None: if user.is_active: auth.login(request, user) return HttpResponseRedirect(redirect) if registration_form.is_valid(): u = User(username=request.POST['username'], email=request.POST['email'], ) u.set_password(request.POST['password1']) u.is_active = True u.save() p = Profile(user=u) p.save() user = auth.authenticate(username=request.POST['username'], password=request.POST['password1']) auth.login(request, user) return HttpResponseRedirect(redirect) return render_to_response('login.html', { 'login_form': login_form, 'registration_form': registration_form, 'redirect' : redirect, }, context_instance = RequestContext(request) )
def createUser(request): if request.method == 'POST': # If the form has been submitted... form = RegistrationForm(request.POST) # A form bound to the POST data if form.is_valid(): # All validation rules pass try: form.save() except ValidationError, err: error = unicode(err) return render(request, 'createuser.html', { 'form': form, 'error': error }) return HttpResponseRedirect('/thanks/') # Redirect after POST
def subscribe(request): if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): user = User.objects.create_user( username=form.cleaned_data['username'], password=form.cleaned_data['password1'], email=form.cleaned_data['email'] ) return HttpResponseRedirect('/') else: form = RegistrationForm() return render(request, 'general/signup.html',{'form': RegistrationForm()})
def __init__(self, *args, **kwargs): user_profile_instance = kwargs.pop('user_profile_instance', None) captcha_answer = kwargs.pop('captcha_answer', None) RegistrationForm.__init__(self, captcha_answer=captcha_answer, *args, **kwargs) ArtistProfileUpdateForm.__init__( self, user_profile_instance=user_profile_instance, *args, **kwargs) # Move CAPTCHA and EULA fields to the end self.fields.keyOrder.remove('captcha') self.fields.keyOrder.remove('over13') self.fields.keyOrder.remove('accept_eula') self.fields.keyOrder.extend(['captcha', 'over13', 'accept_eula'])
def cal(request): if request.method == 'POST': form = RegistrationForm(request.POST) result = 0 if form.is_valid(): result = 1 Line = form.cleaned_data['LineCode'] Machine = form.cleaned_data['MachineCode'] Product = form.cleaned_data['ProductCode'] result = OEEcal(Line, Machine, Product) return render(request, 'production/index.html', { 'result': result, 'te': 1 })
def register(request): if request.POST: # load up the form with data from the POST request form = RegistrationForm(request.POST) if form.is_valid(): user = User.objects.create_user(username=form.cleaned_data['email'], email=form.cleaned_data['email'], password=form.cleaned_data['password']) return render(request, 'register_result.html', {'email': user.username}) else: print form.errors else: form = RegistrationForm() return render(request, 'register.html', {'form': form})
def login(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME): "Displays the login form and handles the login action." redirect_to = request.REQUEST.get(redirect_field_name, '') if request.method == "POST": form = AuthenticationForm(data=request.POST) if form.is_valid(): # Light security check -- make sure redirect_to isn't garbage. if not redirect_to or '//' in redirect_to or ' ' in redirect_to: redirect_to = settings.LOGIN_REDIRECT_URL from django.contrib.auth import login login(request, form.get_user()) if request.session.test_cookie_worked(): request.session.delete_test_cookie() return HttpResponseRedirect(redirect_to) else: form = AuthenticationForm(request) request.session.set_test_cookie() if Site._meta.installed: current_site = Site.objects.get_current() else: current_site = RequestSite(request) return render_to_response(template_name, { 'form': form, 'reg_form': RegistrationForm(), redirect_field_name: redirect_to, 'site_name': current_site.name, }, context_instance=RequestContext(request))
def clean(self): email_username, email_domain = parse_email(self.cleaned_data.get('email', '')) if not email_username: return self.cleaned_data self.cleaned_data['username'] = email_username self.cleaned_data['username'] = RegistrationForm.clean_username(self) return self.cleaned_data
def save(self, commit=True): user = RegistrationForm.save(self, commit=commit) profile = user.get_profile() artist_profile = ArtistProfileUpdateForm.save(self, profile, commit=commit) return user
def register(request): is_registered = False if request.method == 'POST': form = RegistrationForm(data=request.POST) if form.is_valid(): backend = DefaultBackend() new_user = backend.register(request, **form.cleaned_data) is_registered = True else: is_registered = False else: is_registered = False result = {"Status": is_registered} response = json.dumps(result) return HttpResponse(response)
def register(self, form): """ Save all the fields not included in the standard `RegistrationForm` into the JSON `data` field of an `ExtraUserDetail` object """ ## ANTEA START # if REGISTRATION_DEFAULT_FROM_EMAIL email is set, send validation account mail to this email import os new_user_email = form.instance.email if os.environ.get('REGISTRATION_DEFAULT_FROM_EMAIL'): form.instance.user_email = new_user_email form.instance.email = os.environ.get( 'REGISTRATION_DEFAULT_FROM_EMAIL') form.cleaned_data['email'] = os.environ.get( 'REGISTRATION_DEFAULT_FROM_EMAIL') ## ANTEA END standard_fields = set(RegistrationForm().fields.keys()) extra_fields = set(form.fields.keys()).difference(standard_fields) # Don't save the user unless we successfully store the extra data with transaction.atomic(): new_user = super().register(form) extra_data = {k: form.cleaned_data[k] for k in extra_fields} new_user.extra_details.data.update(extra_data) new_user.extra_details.save() ## ANTEA START # and reset the email to the new user new_user.email = new_user_email new_user.save() ## ANTEA END return new_user
def create_user(request, post_data, files): """Create new user from a distutil client request""" form = RegistrationForm({"username": post_data["name"], "email": post_data["email"], "password1": post_data["password"], "password2": post_data["password"]}) if not form.is_valid(): # Dist Utils requires error msg in HTTP status: "HTTP/1.1 400 msg" # Which is HTTP/WSGI incompatible, so we're just returning a empty 400. return HttpResponseBadRequest() backend = get_backend("registration.backends.default.DefaultBackend") if not backend.registration_allowed(request): return HttpResponseBadRequest() new_user = backend.register(request, **form.cleaned_data) return HttpResponse("OK\n", status=200, mimetype='text/plain')
def get_context_data(self, **kwargs): login_form = AuthenticationForm() registration_form = RegistrationForm() context = super(HomeView, self).get_context_data(**kwargs) context['login_form'] = login_form context['registration_form'] = registration_form return context
def home_page(request): context = {} context.update(csrf(request)) context.update({'reg_form': RegistrationForm()}) context.update({'login_form': AuthenticationForm()}) return render(request, 'geodjango/index.html', context)
def register(request, success_url='/accounts/register/complete/', template_name='registration_form.html'): """ Allows a new user to register an account. A customised variation of the view of the same name from django-registration. Context:: form The registration form Template:: registration/registration_form.html (or template_name argument) """ if request.method == 'POST': form = RegistrationFormOpenID(request.POST, request=request) if form.is_valid(): RegistrationProfile.objects.create_inactive_user( username=form.cleaned_data['username'], password=form.cleaned_data['password1'], email=form.cleaned_data['email'], ) return HttpResponseRedirect(success_url) else: form = RegistrationForm() return render_to_response(template_name, {'form': form}, context_instance=RequestContext(request))
def index(request): if not request.user.is_authenticated(): if WEBSITE == 'murmur': return render_to_response('home.html', { 'form': AuthenticationForm(), 'reg_form': RegistrationForm() }, context_instance=RequestContext(request)) elif WEBSITE == 'squadbox': return render_to_response('squadbox/home.html', { 'form': AuthenticationForm(), 'reg_form': RegistrationForm() }, context_instance=RequestContext(request)) else: return HttpResponseRedirect('/posts')
def home(request): ''' if request.method == 'POST': print "post" registration_form = RegistrationForm(request.POST) if registration_form.is_valid(): new_user = registration_form.save() return HttpResponseRedirect('/profile/') else: print "not post" ''' if request.user.is_authenticated(): return HttpResponseRedirect('/profile') registration_form = RegistrationForm() print "out" t = get_template('index2.html') context = { 'user': request.user, # 'registration_form': registration_form, # 'login_form': AuthenticationForm(), } context.update(csrf(request)) return render_to_response('index2.html', context)
def home(request, template_name="registration/register.html"): """Home view""" # NOTE: Only using the actual 'django form' on the POST side b/c we could # be running split tests on the actual form elements (some are shown and # some aren't, etc.). So, it's just easier to render the form ourselves on # the template side. if request.method == 'POST': form = RegistrationForm(request.POST) if not form.is_valid(): return render(request, template_name, {'test_choice': int(request.POST['choice']), 'form': form}) if form.cleaned_data['choice'] > 0: choice = form.cleaned_data['choice'] try: result = TestResult.objects.get(pk=choice) except TestResult.DoesNotExist: result = _create_result_object(choice) if result is not None: result.conversions += 1 result.save() # NOTE: The data could easily be saved here into the standard django # User model or a custom one. However, the point of this app is just # to demonstrate A/B split testing, not saving user information. return HttpResponseRedirect('/register/thanks') else: # See if there's a test running for this url choice = _get_choice_for_split_test('registration.views.home') if choice > 0: try: result = TestResult.objects.get(pk=choice) except TestResult.DoesNotExist: result = _create_result_object(choice) if result is not None: result.visitors += 1 result.save() return render(request, template_name, {'test_choice': choice})
def register(request): if request.POST: # load up the form with data from the POST request form = RegistrationForm(request.POST) if form.is_valid(): first_name = form.cleaned_data['first_name'] last_name = form.cleaned_data['last_name'] user = create_fingr_user(form.cleaned_data['email'], form.cleaned_data['password'], first_name=first_name, last_name=last_name) verification(form.cleaned_data['email'], user, request) return render(request, 'register_result.html', {'email': user.username}) else: form = RegistrationForm() return render(request, 'register.html', {'form': form})
def post(self, request, *args, **kwargs): form = RegistrationForm(request.POST or None) if form.is_valid(): new_user = form.save(commit=False) username = form.cleaned_data['username'] password = form.cleaned_data['password'] new_user.set_password(password) password_check = form.cleaned_data['password_check'] # phone = form.cleaned_data['phone'] email = form.cleaned_data['email'] new_user.save() UserAccount.objects.create( user=User.objects.get(username=new_user.username), email=new_user.email) return HttpResponseRedirect('/') context = {'form': form} return render(self.request, self.template, context)
def register(request): """ Registration form. Creates inactive user (which in turn sends an activation email) and redirect to registration complete page. """ form = RegistrationForm() if request.method == "POST": form = RegistrationForm(request.POST) if form.is_valid(): new_user = User.objects.create_inactive_user(**form.cleaned_data) username = form.cleaned_data['email'] password = form.cleaned_data['password1'] user = authenticate(username=username, password=password) expire_login(request, user) return HttpResponseRedirect('/accounts/register/complete/') return HttpResponse(json.dumps({'errors': form.errors.items()}))
def context(self, request, **kwargs): querystring = "?%s" % request.META.get('QUERY_STRING') if request.POST and self.submit_btn_name() in request.POST: # If data is being posted to this specific block, give the form # the opportunity to render any errors. return { 'registration_action': querystring, 'query_string': querystring, 'registration_form': RegistrationForm(request.POST, auto_id=False), 'registration_submit_btn_name': self.submit_btn_name(), } return { 'registration_action': querystring, 'registration_form': RegistrationForm(), 'registration_submit_btn_name': self.submit_btn_name(), }
def index(request): if request.user.is_authenticated(): return render(request, "dashboard.html") else: return render( request, "index.html", { "login_form": AuthenticationForm(), "registration_form": RegistrationForm(), })
def create_user(request, post_data, files, backend_name=DEFAULT_BACKEND): """Create new user from a distutil client request""" form = RegistrationForm({ "username": post_data["name"], "email": post_data["email"], "password1": post_data["password"], "password2": post_data["password"] }) if not form.is_valid(): # Dist Utils requires error msg in HTTP status: "HTTP/1.1 400 msg" # Which is HTTP/WSGI incompatible, so we're just returning a empty 400. return HttpResponseBadRequest() backend = get_backend(backend_name) if not backend.registration_allowed(request): return HttpResponseBadRequest() new_user = backend.register(request, **form.cleaned_data) return HttpResponse("OK\n", status=200, mimetype='text/plain')
def register(request, template_name='static_pages/splash.html'): if request.method == 'POST': form = RegistrationForm(data=request.POST, files=request.FILES) if form.is_valid(): username = form.cleaned_data['email'].split('@')[0] email = form.cleaned_data['email'] password = form.cleaned_data['password1'] if Site._meta.installed: site = Site.objects.get_current() else: site = RequestSite(request) new_user = RegistrationProfile.objects.create_inactive_user(username, email, password, site) signals.user_registered.send(sender=RegistrationProfile, user=new_user, request=request) profile = UserProfile.objects.get(user=new_user) profile.save() # Check if the email matches a professor in the db try: professor = Professor.objects.get(email=email) profile.professor_assoc = professor profile.save() except Professor.DoesNotExist: # Not a professor in our db, but user came from # professor registration page if request.POST.get('is_professor', False): # is_professor field is only for validation return redirect('prof_reg_error') # else drop down to normal registration messages.add_message(request, messages.INFO, "Thanks for signing up! Check your email for an activation link.") success_url = request.GET.get('next') if success_url: return redirect(success_url) else: return redirect('index') else: form = RegistrationForm() return TemplateResponse(request, template_name, {'form': form})
def school_info(request): if request.method == 'POST': # adminForm.clean() try: form = SchoolForm(request.POST, instance=request.session['school']) except: new = True request.session['school'] = School() form = SchoolForm(request.POST, instance=request.session['school']) # sem.school=request.session['school'] if 'password1' in request.POST: adminForm = RegistrationForm(request.POST) else: adminForm = None if adminForm and adminForm.is_valid(): admin = User.objects.create_user(username=adminForm.cleaned_data['email'], email=adminForm.cleaned_data['email'], password=adminForm.cleaned_data[ 'password1']) role = Role(user=admin, is_admin=True) role.save() if form.is_valid(): request.session['school'].admin = admin form.instance form.save() return HttpResponseRedirect('/') else: print 'form not valid', dir(form) else: # GET try: form = SchoolForm(instance=request.session['school']) except: new = True request.session['school'] = School() form = SchoolForm(instance=request.session['school']) if not request.session['school'].admin: # admin is in adminForm = RegistrationForm() return my_render_to_response(request, 'school_info.html', locals())
def register(request): if request.user.is_authenticated(): return redirect('edit_profile') if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): user = form.save() #user = auth.authenticate(username=username, password=password) #assert user and user.is_authenticated() #auth.login(request, user) return redirect('registration_completed') else: form = RegistrationForm() return TemplateResponse(request, 'registration/register.html', {'form': form})
def register(request): member_form = MemberForm(request.POST or None) registration_form = RegistrationForm(request.POST or None) if request.method == 'POST': member_form = MemberForm(request.POST, request.FILES) registration_form = RegistrationForm(request.POST) if member_form.is_valid() and registration_form.is_valid(): member_form.save() registration_form.save() registration_form.new_person_form = member_form registration_form.save() else: member_form = member_form registration_form = registration_form return render(request, 'registration/registration_form.html', { 'member_form': member_form, 'registration_form': registration_form, })
def professor_register(request, template_name='cr_registration/professor_registration_form.html'): # if request.user.is_authenticated(): # return redirect('index') if request.method == 'POST': form = RegistrationForm(data=request.POST) if form.is_valid(): try: # professor = Professor.objects.get(email=form.cleaned_data['email']) return register(request, template_name='cr_registration/professor_registration_form.html') except Professor.DoesNotExist: return redirect('prof_reg_error') else: return TemplateResponse(request, template_name, {'form': form}) else: form = RegistrationForm() return TemplateResponse(request, template_name, {'form': form})
def _register_all(): anon_racks = Rack.objects.filter(user=u"") addrs = set([rack.email.strip() for rack in anon_racks]) names_seen = set() current_site = Site.objects.get(id=settings.SITE_ID) for email in addrs: name = email.split("@", 1)[0] name = name.replace("+", "_") # XXX do more cleanup if name in names_seen: raise ValueError("Oh crap, already saw name %r" % name) names_seen.add(name) password = randpass() # Just so we always have a non-empty password. data = {"username": name, "email": email, "password1": password, "password2": password} template_args = { "name": name, "email": email, "domain": current_site.domain, "password": password, "activation_days": settings.ACCOUNT_ACTIVATION_DAYS, } form = RegistrationForm(data=data) if form.is_valid(): # Register an inactive account and get the key. template = register_email_txt user = form.save() reg_profile = RegistrationProfile.objects.filter(user=user)[0] template_args["key"] = reg_profile.activation_key # We also need to provide a way to set your password. template_args["password_reset_token"] = default_token_generator.make_token(user) template_args["uidb36"] = int_to_base36(user.id) # user.delete(); reg_profile.delete() #XXX remove this when everything works else: if form.errors.get("username", [""])[0].count(u"already taken"): # Send an email without the link to the predetermined username. template = register_email_name_taken_txt else: print "Problem with address %s:" % email import pprint pprint.pprint(form.errors) continue send_email(template, **template_args)
def index(request): if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): form.save() return redirect('registration/registered') else: form = RegistrationForm() args = {'form': form} return render(request, 'registration/index.html', args)
def register(request): if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): user = User.objects.create_user( username=form.cleaned_data['username'], password=form.cleaned_data['password1'], email=form.cleaned_data['email'], first_name=form.cleaned_data['firstname'], last_name=form.cleaned_data['lastname'], is_active=False, ) return HttpResponseRedirect('success/') else: form = RegistrationForm() variables = RequestContext(request, {'form': form}) return render_to_response( 'registration/register.html', variables, )
def register(request): if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): form.save() return redirect('pvm_forms:index') else: form = RegistrationForm() return render(request, 'registration/register.html', {'form': form})
def signup(request): if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): user = form.save(commit=False) user.is_active = False user.save() current_site = get_current_site(request) subject = 'Activate Your MySite Account' message = render_to_string( 'prabhav/registration/account_activation_email.html', { 'user': user, 'domain': current_site.domain, # 'uid': urlsafe_base64_encode(force_bytes(user.pk)), 'uid': urlsafe_base64_encode(force_bytes( user.pk)).decode(), 'token': account_activation_token.make_token(user), }) from_email = [settings.EMAIL_HOST_USER] to_email = [user.email] send_mail(subject=subject, from_email=from_email, recipient_list=to_email, message=message, fail_silently=False) return redirect('account_activation_sent') else: form = RegistrationForm() return render(request, 'prabhav/registration/signup.html', {'form': form})
def get(self, request, *args, **kwargs): language = request.LANGUAGE_CODE challenge = Challenge.get_unsolved_challenge(language=language) challenge_id = challenge.id if challenge else None order_id = Registration.generate_order_id() context = { 'order_id': order_id, 'form': RegistrationForm(challenge=challenge), 'stripe_public_key': self.get_stripe_public_key(), 'challenge_id': challenge_id } print 'GET ====== ' return render(request, self.template_name, context)
def register(self, request, form, *args, **kwargs): ''' Save all the fields not included in the standard `RegistrationForm` into the JSON `data` field of an `ExtraUserDetail` object ''' standard_fields = set(RegistrationForm().fields.keys()) extra_fields = set(form.fields.keys()).difference(standard_fields) # Don't save the user unless we successfully store the extra data with transaction.atomic(): new_user = super(ExtraDetailRegistrationView, self).register(request, form, *args, **kwargs) extra_data = {k: form.cleaned_data[k] for k in extra_fields} new_user.extra_details.data.update(extra_data) new_user.extra_details.save() return new_user
def register(request, disallowed_url='registration_disallowed', template_name='registration/registration.html'): """用户注册 """ # 是否允许用户进行注册 allow_register = getattr(settings, 'REGISTRATION_OPEN', False) if not allow_register: return redirect(disallowed_url) if request.method == 'POST': form = RegistrationForm(request.POST) # 数据验证 if form.is_valid(): username = form.cleaned_data['username'] email = form.cleaned_data['email'] password = form.cleaned_data['password1'] # 创建一个未激活的用户和默认的扩展属性 act_key = TeamProfile.objects.create_inactive_user( username, email, password) # 直接将激活码作为链接发给用户 to, args, kwargs = ('registration_activate', (), { 'activation_key': act_key }) return redirect(to, *args, **kwargs) else: form = RegistrationForm() context = RequestContext(request) return render_to_response(template_name, {'form': form}, context_instance=context)