def login(request): REDIRECT_URI = request.POST.get('next', request.GET.get('next', reverse("home", kwargs={}))) #next indicated in templaetes if request.method == 'GET': code = request.GET.get('code') if code: redirect_to = "http://%s%s" % (request.META['HTTP_HOST'], reverse("home", kwargs={})) # redirection URL after authenticate api = WeixinMpAPI(appid=APP_ID, app_secret=APP_SECRET, redirect_uri=redirect_to) auth_info = api.exchange_code_for_access_token(code=code) api = WeixinMpAPI(access_token=auth_info['access_token']) api_user = api.user(openid=auth_info['openid']) user = authenticate(request = request, user = api_user) if user and not user.is_anonymous(): auth_login(request, user) return redirect(redirect_to) return redirect(reverse("auth_login", kwargs={})) else: #normal login is POST REDIRECT_FIELD_NAME = 'next' return auth_views.login(request, redirect_field_name=REDIRECT_FIELD_NAME, extra_context=None) # below method is also OK username = request.POST['username'] password = request.POST['password'] user = authenticate(request=request, username=username, password=password) if user is not None: auth_login(request, user) else: return redirect(reverse("auth_login", kwargs={})) return auth_views.login(request, redirect_field_name=REDIRECT_URI, extra_context=None)
def signin(request, **kwargs): if request.user.is_authenticated(): return redirect(settings.LOGIN_REDIRECT_URL) elif request.method == 'POST': username = request.POST.get('username', '') password = request.POST.get('password', '') user = auth.authenticate(username=username, password=password) user_filter = User.objects.filter(username=username) user_obj = user_filter[0] if len(user_filter) else None if user and user_obj and user_obj.is_active: log_entry = MyLogEntry(user=User.objects.get(pk=user.id), message="logged in.") log_entry.save() elif username and password: pool = request.POST.get('pool', '') year = request.POST.get('year', '') s = ldap3.Server("ldaps://ldap.42.fr", port=636, use_ssl=True, get_info=ldap3.GET_ALL_INFO) try: c = ldap3.Connection(s, authentication=ldap3.AUTH_SIMPLE, check_names=True, auto_bind=True, user="******"+username+",ou="+pool+",ou="+year+",ou=paris,ou=people,dc=42,dc=fr", password=password) except ldap3.LDAPBindError: return login(request, **kwargs) if c.result['description'] == 'success': user_obj = User.objects.get(username=username) user_obj.set_password(password) user_obj.is_active = True user_obj.save() return login(request, **kwargs)
def entrar(request, template_name): state = "Efetue Login" if request.method == 'POST': # If the form has been submitted... postdata = request.POST.copy() form_login = LoginForm(postdata) if form_login.is_valid(): cd = form_login.cleaned_data email = cd.get('email') senha = cd.get('senha') user = authenticate(username=email, password=senha) if user is not None and user.is_active: login(request, user) if request.POST['next']: return HttpResponseRedirect(request.POST['next']) else: return HttpResponseRedirect('/') return HttpResponseRedirect('/') else: return direct_to_template(request, 'invalid_login.html') return HttpResponseRedirect('/') else: initial_data = {} form_login = LoginForm(initial=initial_data) return render_to_response(template_name, { 'form_login' : form_login, 'state':state, }, context_instance=RequestContext( request ) )
def login(request,template_name): from django.contrib.sessions.models import Session from prospere.copia.models import SessionBonds from django.core.exceptions import ObjectDoesNotExist from django.contrib.auth import views from prospere.contrib.cabinet.models import Storages import time if request.method == 'POST': if not 'login_count' in request.session: request.session['login_count'] = 0 if not 'login_expire_time' in request.session : request.session['login_expire_time'] = 0 if time.time() < request.session['login_expire_time']: return direct_to_template(request,'error.html') request.session['login_count'] += 1 if request.session['login_count'] > 10: request.session['login_expire_time'] = time.time() + 60 * 60 request.session['login_count'] = 0 return direct_to_template(request,'error.html') content = views.login(request, template_name) if request.user.is_authenticated(): try: bound = SessionBonds.objects.get(user = request.user) Session.objects.filter(session_key = bound.session_key).delete() bound.session_key = request.session.session_key bound.save() except ObjectDoesNotExist: SessionBonds.objects.create(user=request.user,session_key=request.session.session_key) return content return views.login(request, template_name)
def activate_account(request, code): try: profile = UserProfile.objects.get(activation_code=code) user = profile.user user.is_active = 1 user.save() profile.activation_code = '' profile.save() return login( request, template_name='users/sign_in.haml', extra_context={ 'success': _('Your account has been ' 'successfully activated, you can now sign in.' )}) except UserProfile.DoesNotExist: return login( request, template_name='users/sign_in.haml', extra_context={ 'error': _('This activation link does not exists. ' 'If you are experiencing activation issues, ' 'you can contact us using the contact form.' )})
def registration(request): student = Students() if request.method == "POST": studentForm = StudentsForm(request.POST) if studentForm.is_valid(): userData = studentForm.cleaned_data student.username = userData['username'] student.last_name = userData['last_name'] student.first_name = userData['first_name'] student.other_name = userData['other_name'] student.b_day = userData['b_day'] student.phone = userData['phone'] student.sex = userData['sex'] student.cart = userData['cart'] student.is_elder = userData['is_elder'] student.set_password(userData['pass1']) student.save() user = authenticate(username = userData['username'], password = userData['pass1'] ) login(request, user) return HttpResponseRedirect('/') else: studentForm = StudentsForm(request.POST) else: studentForm = StudentsForm() return render_to_response("profile/registration.html", locals(), context_instance = RequestContext(request))
def login_view(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME, # authentication_form=AuthenticationForm, authentication_form=AuShadhaUserForm, current_app=None, extra_context=None): """Displays the login form and handles the login action.""" redirect_to = request.REQUEST.get(redirect_field_name, '') if request.method == "POST": form = authentication_form(data=request.POST) if form.is_valid(): netloc = urlparse.urlparse(redirect_to)[1] # Use default setting if redirect_to is empty if not redirect_to: redirect_to = settings.LOGIN_REDIRECT_URL # Heavier security check -- don't allow redirection to a different # host. elif netloc and netloc != request.get_host(): redirect_to = settings.LOGIN_REDIRECT_URL # Okay, security checks complete. Log the user in. login(request, form.get_user()) if request.session.test_cookie_worked(): request.session.delete_test_cookie() data = {'success': True, 'error_message': "Successfully Loggged In !", 'redirect_to': redirect_to } else: data = {'success': False, 'error_message' : '''<em class='error_text'>ERROR! Could not login</em> <p class='suggestion_text'>Please Check your Username & Password.</p> <i class='help_text'>If you are sure they are correct, Please contact Administrator to find out whether you need to activate your account. </i> ''', } json = simplejson.dumps(data) return HttpResponse(json, content_type='application/json') else: form = authentication_form(request) request.session.set_test_cookie() current_site = get_current_site(request) context = { 'form': form, redirect_field_name: redirect_to, 'site': current_site, 'site_name': current_site.name, } if extra_context is not None: context.update(extra_context) return TemplateResponse(request, template_name, context, current_app=current_app)
def signup(request, template_name='users/signup_form.html', email_template_name='users/signup_email.html', signup_form=UserCreationForm, token_generator=default_token_generator, post_signup_redirect=None): if request.user.is_authenticated(): return redirect('/users/home') if post_signup_redirect is None: post_signup_redirect = reverse('app.users.views.home') if request.method == "POST": form = signup_form(request.POST) if form.is_valid(): opts = {} opts['use_https'] = request.is_secure() opts['token_generator'] = token_generator opts['email_template_name'] = email_template_name #if not Site._meta.installed: opts['domain_override'] = get_current_site(request).domain user = form.save(**opts) user = authenticate(username=user.username,password=user.password) if user is not None: if user.is_active: login(request, user) # Redirect to a success page. #else: # Return a 'disabled account' error message return HttpResponseRedirect(post_signup_redirect) else: form = signup_form() return render_to_response(template_name, {'form': form,}, context_instance=RequestContext(request))
def login(request): template = 'login.html' if request.user.is_authenticated: HttpResponseRedirect('/') else: login(request) return render_to_response(template,context_instance=RequestContext(request))
def login_page(request): if request.user.is_authenticated(): return HttpResponseRedirect('/user/%s' % request.user.username) else: if request.method == 'POST': form = LoginForm(request.POST) if form.is_valid(): if not request.POST.get('remember', None): request.session.set_expiry(0) username=request.POST['username'] password=request.POST['password'] user = authenticate(username=username, password=password) if user is not None: if user.is_active: login(request, user) return HttpResponseRedirect('/') else: return HttpResponse('Your account is not active') else: return HttpResponse('Invalid login') else: form = LoginForm() var = RequestContext(request, { 'head_title': 'Login', 'title':'LOGIN', 'form':form, }) return render_to_response('registration/login.html', RequestContext(request, var))
def login_view(request): """Login a User""" form = form_data(request) login(request) return render(request, "registration/login.html", {'form':form})
def login(self, request, **kwargs): self.method_check(request, allowed=['post']) data = self.deserialize(request, request.raw_post_data, format=request.META.get('CONTENT_TYPE', 'application/json')) username = data.get('username', '') password = data.get('password', '') user = authenticate(username=username, password=password) if user: if user.is_active: login(request, user) bundle = self.build_bundle(obj=user, request=request) bundle = self.full_dehydrate(bundle) bundle = self.alter_detail_data_to_serialize(request, bundle) return self.create_response(request, bundle) else: return self.create_response(request, { 'success': False, 'reason': 'disabled', }, HttpForbidden) else: return self.create_response(request, { 'success': False, 'reason': 'incorrect', }, HttpUnauthorized)
def process_request(self, request): if request.path != "/login" and request.user.is_anonymous(): if request.POST: login(request) return HttpResponseRedirect("/") else: return HttpResponseRedirect("%s?next=%s" % ("/login", request.path))
def get(self, request, key): verification_key_object = get_object_or_404(VerificationKey, key=key) if not verification_key_object.is_valid: message = u'Ссылка недействительна, попробуйте получить новую.' return self.render_to_response({'message': message}) user = verification_key_object.user if get_user_by_email(user.email): message = u'Адрес, который вы пытаетесь подтвердить уже зарегистрирован и подтвержден.' return self.render_to_response({'message': message}) else: verification_key_object.unused = False verification_key_object.save() profile = user.get_profile() profile.email_verified = True profile.save() message = u'Адрес электронной почты %s подтвержден!' % user.email messages.info(request, message) action_flag = EMAIL_VERIFICATION context_dict = {'email': user.email} extra = { 'user': user, 'obj': profile, } Logger.objects.create_for_action(action_flag, context_dict=context_dict, extra=extra) if user.is_active: backend = get_backends()[1] user.backend = "%s.%s" % (backend.__module__, backend.__class__.__name__) login(request, user) return HttpResponseRedirect(reverse('frontpage'))
def process_request(self, request): """ Add `facebook` into the request context and attempt to authenticate the user. If no user was found, request.facebook will be None. Otherwise it will contain a DjangoFacebook object containing: uid: The facebook users UID user: Any user information made available as part of the authentication process graph: A GraphAPI object connected to the current user. An attempt to authenticate the user is also made. The fb_uid and fb_graphtoken parameters are passed and are available for any AuthenticationBackends. The user however is not "logged in" via login() as facebook sessions are ephemeral and must be revalidated on every request. """ fb_user = self.get_fb_user(request) request.facebook = DjangoFacebook(fb_user) if fb_user else None if fb_user and request.user.is_anonymous(): user = auth.authenticate(fb_uid=fb_user['uid'], fb_graphtoken=fb_user['access_token']) if user: user.last_login = datetime.datetime.now() user.save() login(request, user) if user.is_authenticated: print "success" request.user = user return None
def register(request): '''View to handle registration''' data = request.POST if request.POST else None form = RegistrationForm(data) match_flag = True if request.method == 'POST': if form.is_valid(): username = form.cleaned_data['username'] email = form.cleaned_data['email'] first_name = form.cleaned_data['first_name'] last_name = form.cleaned_data['last_name'] password = form.cleaned_data['password'] repeat_password = form.cleaned_data['repeat_password'] if password == repeat_password: user = User.objects.create_user(username, email, password, first_name=first_name, last_name=last_name) user = authenticate(username=username, password=password) if user is not None: if user.is_active: views.login(request, user) return redirect('login') else: match_flag = False return render(request, "register.html", locals())
def login(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME, authentication_form=LoginForm): ''' Displays the login form and handles the login action. When the User is logged on, we'll try to read the language from his/her profile and update the current language accordingly. ''' if django.VERSION < (1, 2): response = auth_views.login(request, template_name=template_name, redirect_field_name=redirect_field_name) else: response = auth_views.login(request, template_name=template_name, redirect_field_name=redirect_field_name, authentication_form=authentication_form) if request.method == 'POST': try: p = request.user.get_profile() except AttributeError: lang_code = translation.get_language() except ObjectDoesNotExist: lang_code = translation.get_language() else: lang_code = p.language if lang_code == '': lang_code = translation.get_language() p.language = lang_code p.save() set_language_on_response(request, response, lang_code) return response
def customlogin(request): returnJson = ifReturnJson(request) if request.method == 'POST': data_dict = {} data_dict['type'] = 'login' username = request.POST['username'] password = request.POST['password'] user = authenticate(username=username, password=password) if user is not None: data_dict['uid'] = user.id data_dict['username'] = user.username data_dict['name'] = user.first_name + user.last_name data_dict['email'] = user.email if user.is_active: # Redirect to a success page. data_dict['success'] = 1 else: # Return a 'disabled account' error message data_dict['success'] = 0 data_dict['error_message'] = 'disabled account' else: data_dict['success'] = 0 data_dict['error_message'] = 'username and password not match' if returnJson == 1: return HttpResponse(json.dumps(data_dict),content_type='application/json') elif returnJson == 0: return login(request) return login(request)
def signup_page(request): if request.method == 'POST': form = SignupForm(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'] ) name_split = shlex.split(form.cleaned_data['fullname']) fname = name_split[0] lname = '' for x in name_split[1:]: lname += (x + ' ') user.first_name = fname user.last_name = lname user.save() login(request,user) return HttpResponseRedirect('/follow-topics/') else: form = SignupForm() var = RequestContext(request, { 'form': form }) return render_to_response('registration/signup.html', var)
def login(request, template_name): if request.method == "POST": # Default error_message error_message = "Password not valid" try: username = request.POST.get("username", "").strip() # Check if user entered email to login if email_re.search(username): # "username" is an email. Get his/her username. user = User.objects.get(email=username) else: # Get real username in case user entered ignore-case username user = User.objects.get(username__iexact=username) post_copy = request.POST.copy() post_copy["username"] = user.username request.POST = post_copy except User.DoesNotExist: error_message = "Username doesn't exist" response = auth_views.login(request, template_name) ip_address = request.META.get("REMOTE_ADDR") if type(response) == HttpResponseRedirect: UserSession.objects.create(user=user, ip_address=ip_address) logger.info("%s - account-login: user '%s'" % (ip_address, username)) else: logger.error("%s - account-login: user '%s', error: '%s'" % (ip_address, username, error_message)) else: response = auth_views.login(request, template_name) return response
def sign_in_stage2_with_token(request, user_id, sign_in_key): if settings.STUDENT_SIGN_IN_VIEW != "relate-sign_in_by_email": raise SuspiciousOperation(_("email-based sign-in is not being used")) from django.contrib.auth import authenticate, login user = authenticate(user_id=int(user_id), token=sign_in_key) if user is None: messages.add_message(request, messages.ERROR, _("Invalid sign-in token. Perhaps you've used an old " "token email?")) raise PermissionDenied(_("invalid sign-in token")) if not user.is_active: messages.add_message(request, messages.ERROR, _("Account disabled.")) raise PermissionDenied(_("invalid sign-in token")) login(request, user) if not (user.first_name and user.last_name): messages.add_message(request, messages.INFO, _("Successfully signed in. " "Please complete your registration information below.")) return redirect( reverse("relate-user_profile")+"?first_login=1") else: messages.add_message(request, messages.INFO, _("Successfully signed in.")) return redirect("relate-home")
def secure_login(request): """ A replacement for Django's default login view that sends the user to an ssl url on a different domain ("settings.SSL_DOMAIN"). This is needed to work around GAEs limitation with ssl only working on ".appspot.com" domains. """ if request.is_secure(): login_response = auth_views.login(request) # Django's login view has a "light security check" that won't allow redirecting # to absolute urls, so we have to do it manually (potentially spoiling the security) picks_url = request.GET.get(PICK_SESSION_URL_PARAM, None) if isinstance(login_response, HttpResponseRedirect) and picks_url: get = request.GET.copy() del get[PICK_SESSION_URL_PARAM] get[SESSION_KEY_PARAM] = request.session.session_key return HttpResponseRedirect("%s?%s" % (picks_url, get.urlencode())) else: return login_response elif not settings.DEBUG: get = request.GET.copy() get[PICK_SESSION_URL_PARAM] = request.build_absolute_uri(reverse(pick_session)) next = "%s?%s" %(reverse(secure_login), get.urlencode()) qd = QueryDict('').copy() qd[REDIRECT_FIELD_NAME] = next qd[SESSION_KEY_PARAM] = request.session.session_key return HttpResponseRedirect("https://%s%s?%s" % (settings.SSL_DOMAIN, reverse(pick_session), qd.urlencode())) # No SSL on dev server, so just invoke the regular login view return auth_views.login(request)
def scripts_login(request, **kwargs): host = request.META['HTTP_HOST'].split(':')[0] if host in ('localhost', '127.0.0.1'): return login(request, **kwargs) if request.META['SERVER_PORT'] == '444': backend = ScriptsRemoteUserBackend() pts_query = pts.PTS(None, pts.PTS_UNAUTH) pts_result = pts_query.getEntry('system:wilg') names = [m._get_name() for m in pts_result.members] email = request.META[ScriptsRemoteUserMiddleware.header] username = backend.clean_username(email) request.META['kerberos'] = username if username in names: if request.user.is_authenticated(): # TODO # They're already authenticated --- redirect to member page response = userena.views.signin(request) return response else: # redirect to login/signup page response = userena.views.signup(request) return response else: return login(request, **kwargs) else: # Move to port 444 redirect_to = "https://%s:444%s" % (host, request.META['REQUEST_URI'], ) return HttpResponseRedirect(redirect_to)
def login(request): """Log the user in. Lifted most of this code from zamboni.""" if 'next' in request.GET: request = _clean_next_url(request) request.session['next'] = request.GET['next'] logout(request) r = auth_views.login(request, template_name='users/signin.html', authentication_form=forms.AuthenticationForm) if isinstance(r, http.HttpResponseRedirect): # Succsesful log in according to django. Now we do our checks. I do # the checks here instead of the form's clean() because I want to use # the messages framework and it's not available in the request there user = request.user.get_profile() if user.confirmation_code: logout(request) log.info(u'Attempt to log in with unconfirmed account (%s)' % user) msg1 = _(('A link to activate your user account was sent by email ' 'to your address {0}. You have to click it before you ' 'can log in.').format(user.email)) url = request.build_absolute_uri( reverse('users_confirm_resend', kwargs=dict(username=user.username))) msg2 = _(('If you did not receive the confirmation email, make ' 'sure your email service did not mark it as "junk ' 'mail" or "spam". If you need to, you can have us ' '<a href="%s">resend the confirmation message</a> ' 'to your email address mentioned above.') % url) messages.error(request, msg1) messages.info(request, msg2, safe=True) return render_to_response('users/signin.html', { 'form': auth_forms.AuthenticationForm(), }, context_instance=RequestContext(request)) if request.POST.get('remember_me', None): request.session.set_expiry(settings.SESSION_COOKIE_AGE) log.debug(u'User signed in with remember_me option') next_param = request.session.get('next', None) if next_param: del request.session['next'] if not next_param.startswith('/'): next_param = '/%s' % (next_param,) return http.HttpResponseRedirect(next_param) elif request.method == 'POST': messages.error(request, _('Incorrect email or password.')) # run through auth_views.login again to render template with messages. r = auth_views.login(request, template_name='users/signin.html', authentication_form=forms.AuthenticationForm) return r
def do_login(request): if request.POST: username = request.POST["username"] password = request.POST["password"] user = authenticate(username=username, password=password) if user: if user.is_active: login(request, user) return HttpResponseRedirect(reverse("home")) return render_to_response("account/login.html", {}, RequestContext(request))
def login(request): from django.contrib.auth.views import login if not request.user.is_authenticated(): return login(request, template_name='webapp/login.html', authentication_form=AuthenticationForm) elif request.GET.get(REDIRECT_FIELD_NAME): return login(request, template_name='webapp/relogin.html', authentication_form=ReauthenticationFormWrapper(user=request.user)) else: return redirect('index')
def process_view(self, request, view_func, view_args, view_kwargs): #DIRTY HACK. CHANGE IT LATER. if hasattr(view_func, 'authentication')\ and not (isinstance(view_func.authentication, NoAuthentication) and view_func.authentication): return if not request.user.is_authenticated(): return login(request, extra_context={"extra_error": ugettext("The system requires you to be authenticated.")}) elif not request.user.is_active: return login(request, extra_context={"extra_error": ugettext("Your account is not active.")})
def login(request): if request.POST: '''login''' print request.POST user = authenticate(username=request.POST.get('username'), password=request.POST.get('password')) if user and user.is_active: views.login(request) return redirect('/') else: form=LoginForm() return render(request,"social/login.html",{'form':form})
def index(request): if request.method == 'POST': if "submit_login" in request.POST: return auth_views.login(request) else: return ViewSupport.handleUserManagementForms_post(request, "/") if request.user.is_authenticated(): return render(request, 'index_loggedin.html') else: return auth_views.login(request, 'registration/login.html')
def login(request): """Log the user in. Lifted most of this code from zamboni.""" request = _process_redirect(request) if request.user.is_authenticated(): user = request.user.get_profile() redirect_url = _get_redirect_url(request) olang = get_language() force_language_in_url( redirect_url, olang, user.preflang) return _after_login_redirect(redirect_url, user) logout(request) dashboard_url = reverse('dashboard') redirect_field_value = request.session.get( REDIRECT_FIELD_NAME, dashboard_url) or dashboard_url try: redirect_field_value = urllib2.quote(redirect_field_value) except KeyError: # Unicode Issue pass extra_context = { 'redirect_field_name': REDIRECT_FIELD_NAME, 'redirect_field_value': redirect_field_value, } r = auth_views.login(request, template_name='users/signin.html', authentication_form=forms.AuthenticationForm, extra_context=extra_context) if isinstance(r, http.HttpResponseRedirect): user = request.user.get_profile() if request.POST.get('remember_me', None): request.session.set_expiry(settings.SESSION_COOKIE_AGE) log.debug(u'User signed in with remember_me option') olang = get_language() activate(user.preflang) redirect_url = _get_redirect_url(request) if redirect_url: redirect_url = force_language_in_url( redirect_url, olang, user.preflang) return _after_login_redirect(redirect_url, user) elif request.method == 'POST': messages.error(request, _('Incorrect username, email or password.')) # run through auth_views.login again to render template with messages. r = auth_views.login(request, template_name='users/signin.html', authentication_form=forms.AuthenticationForm) return r
def photo(request, post_id): postobj = Post.objects.filter(id=post_id) if request.method == 'POST': regform = RegistrationForm(request.POST) postform = PostForm(request.POST, request.FILES) if regform.is_valid(): regform.save() return redirect('/') elif request.user.is_authenticated(): if postform.is_valid(): obj = postform.save(commit=False) obj.user = request.user obj.image = postform.cleaned_data['image'] obj.save() postform.save_m2m() return redirect('/') else: postform = PostForm() regform = RegistrationForm() context = { 'post': postobj, 'regform': regform, 'postform': postform, } return login(request, context, template_name='marketplace/err.html') else: regform = RegistrationForm() postform = PostForm() context = { 'post': postobj, 'regform': regform, 'postform': postform, } return render(request, 'marketplace/image.html', context)
def login(request, *args, **kwargs): """ Modified login view for "remember me" checkbox. Once processed, passes login to default auth views. """ # Check if user is logged in. If so, automatically redirect to index page. if request.user.is_authenticated: return redirect('cae_home:index') # User not logged in. Check if request is POST. if request.method == 'POST': # See if remember_me box is checked. if request.POST.get('remember_me', None): # Remember me is checked. Hold user session indefinitely. request.session.set_expiry(0) else: # Remember me is not checked. Set session to time out in 3600 seconds (1 hour). request.session.set_expiry(3600) return auth_views.login(request, *args, authentication_form=forms.AuthenticationForm, **kwargs)
def limited_login(request): if 'username' in request.POST: username = request.POST['username'] try: user = User.objects.get(username=username) except: user = None else: user = None if user is not None and user.username in request.session: if not user.is_superuser and request.session[user.username] >= 3: user.is_staff = False user.save() return HttpResponse('密码输入错误3次, 账户已锁定!') rep = login(request) status_code = rep.status_code if status_code == 200 and user is not None: if user.username in request.session: request.session[user.username] += 1 else: request.session[user.username] = 1 return rep
def login(self, request, extra_context=None): """ Displays the login form for the given HttpRequest. """ from django.contrib.auth.views import login def captched_form(req=None, data=None): return CaptchaAuthenticationForm( req, data, initial={'captcha': request.META['REMOTE_ADDR']}) # If the form has been submitted... template_name = "accounts/login.jade" context = { 'title': _('Log in'), 'app_path': request.get_full_path(), REDIRECT_FIELD_NAME: request.get_full_path(), } context.update(extra_context or {}) login_form = AdminAuthenticationForm if request.method == "POST": login_try_count = request.session.get('login_try_count', 0) request.session['login_try_count'] = login_try_count + 1 if login_try_count >= 2: login_form = captched_form defaults = { 'extra_context': context, 'current_app': self.name, 'authentication_form': self.login_form or login_form, 'template_name': self.login_template or template_name, } return login(request, **defaults)
def login(request, template_name=None, extra_context=None, **kwargs): """Logs a user in using the :class:`~openstack_auth.forms.Login` form.""" # If the user enabled websso and selects default protocol # from the dropdown, We need to redirect user to the websso url if request.method == 'POST': auth_type = request.POST.get('auth_type', 'credentials') if utils.is_websso_enabled() and auth_type != 'credentials': auth_url = request.POST.get('region') url = utils.get_websso_url(request, auth_url, auth_type) return shortcuts.redirect(url) if not request.is_ajax(): # If the user is already authenticated, redirect them to the # dashboard straight away, unless the 'next' parameter is set as it # usually indicates requesting access to a page that requires different # permissions. if (request.user.is_authenticated() and auth.REDIRECT_FIELD_NAME not in request.GET and auth.REDIRECT_FIELD_NAME not in request.POST): return shortcuts.redirect(settings.LOGIN_REDIRECT_URL) # Get our initial region for the form. initial = {} current_region = request.session.get('region_endpoint', None) requested_region = request.GET.get('region', None) regions = dict(getattr(settings, "AVAILABLE_REGIONS", [])) if requested_region in regions and requested_region != current_region: initial.update({'region': requested_region}) if request.method == "POST": # NOTE(saschpe): Since https://code.djangoproject.com/ticket/15198, # the 'request' object is passed directly to AuthenticationForm in # django.contrib.auth.views#login: if django.VERSION >= (1, 6): form = functional.curry(forms.Login) else: form = functional.curry(forms.Login, request) else: form = functional.curry(forms.Login, initial=initial) if extra_context is None: extra_context = {'redirect_field_name': auth.REDIRECT_FIELD_NAME} if not template_name: if request.is_ajax(): template_name = 'auth/_login.html' extra_context['hide'] = True else: template_name = 'auth/login.html' res = django_auth_views.login(request, template_name=template_name, authentication_form=form, extra_context=extra_context, **kwargs) # Save the region in the cookie, this is used as the default # selected region next time the Login form loads. if request.method == "POST": utils.set_response_cookie(res, 'login_region', request.POST.get('region', '')) utils.set_response_cookie(res, 'login_domain', request.POST.get('domain', '')) # Set the session data here because django's session key rotation # will erase it if we set it earlier. if request.user.is_authenticated(): auth_user.set_session_from_user(request, request.user) regions = dict(forms.Login.get_region_choices()) region = request.user.endpoint region_name = regions.get(region) request.session['region_endpoint'] = region request.session['region_name'] = region_name return res
def index(request): if request.user.is_authenticated(): return HttpResponseRedirect('/tv/') else: return login(request)
def login(request): auth_views.login(request) return render(request, 'registration/login.html')
def post(self, request, *args, **kwargs): return auth_views.login(request)
def otp_login(request, **kwargs): from django.contrib.auth.views import login kwargs = get_otp_form(request, always=True, **kwargs) return login(request, **kwargs)
def login(request): return auth_views.login(request, "users/login.html")
def login(request): kwargs = { 'template_name': 'account/login.html', 'authentication_form': LoginForm} return django_views.login(request, **kwargs)
def form_valid(self, form): login(self.request, form.get_user()) return HttpResponseRedirect(self.get_success_url())
def login(request, *args, **kwargs): if request.method == 'POST': if not request.POST.get('remember', None): request.session.set_expiry(0) return views.login(request, *args, **kwargs)
def login_skwissh(request): return login(request, 'skwissh_login.html', extra_context={ 'skwissh_demo': getattr(settings, "SKWISSH_DEMO", False) })
def login(request): #extra_context是一个字典,它将作为context传递给template,这里告诉template成功后跳转的页面将是/index template_response = views.login(request, extra_context={'next': '/'}) return template_response
def login(request, template_name=None, extra_context=None, **kwargs): """Logs a user in using the :class:`~openstack_auth.forms.Login` form.""" # If the user enabled websso and selects default protocol # from the dropdown, We need to redirect user to the websso url if request.method == 'POST': auth_type = request.POST.get('auth_type', 'credentials') if utils.is_websso_enabled() and auth_type != 'credentials': auth_url = request.POST.get('region') url = utils.get_websso_url(request, auth_url, auth_type) return shortcuts.redirect(url) if not request.is_ajax(): # If the user is already authenticated, redirect them to the # dashboard straight away, unless the 'next' parameter is set as it # usually indicates requesting access to a page that requires different # permissions. if (request.user.is_authenticated() and auth.REDIRECT_FIELD_NAME not in request.GET and auth.REDIRECT_FIELD_NAME not in request.POST): return shortcuts.redirect(settings.LOGIN_REDIRECT_URL) # Get our initial region for the form. initial = {} current_region = request.session.get('region_endpoint', None) requested_region = request.GET.get('region', None) regions = dict(getattr(settings, "AVAILABLE_REGIONS", [])) if requested_region in regions and requested_region != current_region: initial.update({'region': requested_region}) if request.method == "POST": form = functional.curry(forms.Login) else: form = functional.curry(forms.Login, initial=initial) if extra_context is None: extra_context = {'redirect_field_name': auth.REDIRECT_FIELD_NAME} if not template_name: if request.is_ajax(): template_name = 'auth/_login.html' extra_context['hide'] = True else: template_name = 'auth/login.html' res = django_auth_views.login(request, template_name=template_name, authentication_form=form, extra_context=extra_context, **kwargs) # Save the region in the cookie, this is used as the default # selected region next time the Login form loads. if request.method == "POST": utils.set_response_cookie(res, 'login_region', request.POST.get('region', '')) utils.set_response_cookie(res, 'login_domain', request.POST.get('domain', '')) # Set the session data here because django's session key rotation # will erase it if we set it earlier. if request.user.is_authenticated(): auth_user.set_session_from_user(request, request.user) regions = dict(forms.Login.get_region_choices()) region = request.user.endpoint login_region = request.POST.get('region') region_name = regions.get(login_region) request.session['region_endpoint'] = region request.session['region_name'] = region_name expiration_time = request.user.time_until_expiration() threshold_days = getattr(settings, 'PASSWORD_EXPIRES_WARNING_THRESHOLD_DAYS', -1) if expiration_time is not None and \ expiration_time.days <= threshold_days: expiration_time = str(expiration_time).rsplit(':', 1)[0] msg = (_('Please consider changing your password, it will expire' ' in %s minutes') % expiration_time).replace( ':', ' Hours and ') messages.warning(request, msg) return res
def login(request, template_name, redirect_field_name=None, authentication_form=ELRIAuthenticationForm ): """Renders login view by connecting to django.contrib.auth.views.""" LOGGER.info(u'Rendering login view for user "{0}".'.format( request.user.username or "Anonymous")) return auth_views.login(request, template_name, redirect_field_name, authentication_form)
def jobfair(request): if request.user.is_authenticated(): return jobfair_invite(request) else: return login(request, 'conf/job-fair-login.html')
def index(request, **kwargs): if request.user.is_authenticated(): return HttpResponseRedirect(reverse("dashboard")) else: return login(request, **kwargs)
def login_page(request): if request.user.is_authenticated(): return HttpResponseRedirect('/home_page/') else: return auth_views.login(request, template_name='divassist_web/registration/login.html')
def custom_login(request, *args, **kwargs): response = login(request, *args, **kwargs) if request.user.is_authenticated(): messages.success(request, "Logged in") return response
def login(request): if request.user.is_authenticated(): return HttpResponseRedirect(reverse('current_profile')) return auth_views.login(request, template_name='login.html')
def post(self, *args, **kwargs): return login(template_name=self.template_name, *args, **kwargs)
def custom_login(request): if request.method == 'GET' and request.user.is_authenticated(): return HttpResponseRedirect(request.GET.get('next', '/')) else: return login(request, template_name='wybory/login.html')
def post(self, request): """ 实现用户注册 :param request: 请求对象 :return: 注册结果 """ #1.接收参数 username = request.POST.get('username') password = request.POST.get('password') password2 = request.POST.get('password2') mobile = request.POST.get('mobile') # TODD:sms_code sms_code_client = request.POST.get('sms_code') allow = request.POST.get('allow') #2.校验参数 # 判断参数是否齐全 if not all([username, password, password2, mobile, allow]): return http.HttpResponseForbidden('缺少必传参数') # 判断用户名是否是5-20个字符 if not re.match(r'^[a-zA-Z0-9_-]{5,20}$', username): return http.HttpResponseForbidden('请输入5-20个字符的用户名') # 判断密码是否是8-20个数字 if not re.match(r'^[0-9A-Za-z]{8,20}$', password): return http.HttpResponseForbidden('请输入8-20位的密码') # 判断两次密码是否一致 if password != password2: return http.HttpResponseForbidden('两次输入的密码不一致') # 判断手机号是否合法 if not re.match(r'^1[3-9]\d{9}$', mobile): return http.HttpResponseForbidden('请输入正确的手机号码') # 获取 redis 链接对象 redis_conn = get_redis_connection('verify_code') # 从 redis 中获取保存的 sms_code sms_code_server = redis_conn.get('sms_code_%s' % mobile) # 判断 sms_code_server 是否存在 if sms_code_server is None: # 不存在直接返回, 说明服务器的过期了, 超时 return render(request, 'register.html', {'sms_code_errmsg': '无效的短信验证码'}) # 如果 sms_code_server 存在, 则对比两者: if sms_code_client != sms_code_server.decode(): # 对比失败, 说明短信验证码有问题, 直接返回: return render(request, 'register.html', {'sms_code_errmsg': '输入短信验证码有误'}) # 判断是否勾选用户协议 if allow != 'on': return http.HttpResponseForbidden('请勾选用户协议') #3.保存到数据库 # 保存注册数据 try: user = User.objects.create_user(username=username, password=password, mobile=mobile) except DatabaseError: return render(request, 'register.html', {'register_errmsg': '注册失败'}) #5.状态保持 login(request, user) # # 响应注册结果 # return http.HttpResponse('保存成功,跳转还没有做到首页') # 响应注册结果 return redirect(reverse('contents:index'))
def custom_login(request): if request.user.is_authenticated: # Redirect to home if already logged in. return HttpResponseRedirect(reverse_lazy("page:home")) else: return login(request)
def custom_login(request): if request.user.is_authenticated(): return redirect('index') else: return login(request)
def login_view(request): if request.user.is_authenticated(): return HttpResponseRedirect('/') else: return login(request, template_name='auth/login.html')
def get(self, _, *args, **kwargs): if self.request.user.is_authenticated(): return redirect(self.get_next_redirect_url()) else: kwargs = {'template_name': 'worker_list.html'} return login(self.request, *args, **kwargs)
def login(request, **kwargs): if not request.user.is_anonymous( ) and request.method == "POST": # We're logging in, so log out first do_logout(request) kwargs.setdefault("extra_context", {})["error"] = request.GET.get("error") return auth_views.login(request, **kwargs)