def login(request, template="accounts/account_login.html"): """ Login form. """ isAjax = False form = LoginForm(request.POST or None) next = get_login_redirect_url(request) if request.method == "POST" and form.is_valid(): authenticated_user = form.save() #info(request, _("Successfully logged in")) auth_login(request, authenticated_user) if request.is_ajax(): if request.user.is_authenticated(): return HttpResponse(simplejson.dumps(dict(url=next, success=True))) else: return HttpResponse(simplejson.dumps(dict(success=False))) else: return login_redirect(request) elif form.errors: return HttpResponse(simplejson.dumps(dict(errors=form.errors, success=False))) if request.is_ajax(): template = "accounts/ajax_account_login.html" context = {"form": form, "title": _("Log in"), "next":next} return render(request, template, context)
def signup(request): if request.method == 'POST': form = SignupForm2(request.POST) if form.is_valid(): user = form.save() # backend_cls = get_backends()[0].__class__ # backend_path = backend_cls.__module__ + '.' + backend_cls.__name__ # https://github.com/django/django/blob/1.9/django/contrib/auth/__init__.py#L81 # user.backend = backend_path authenticated_user = authenticate( username=form.cleaned_data['username'], password=form.cleaned_data['password1']) auth_login(request, authenticated_user) messages.info(request, '환영합니다. ;)') return redirect(settings.LOGIN_REDIRECT_URL) # 회원가입 시에, 이메일 승인 # user = form.save(commit=False) # user.is_active = False # user.save() # send_signup_confirm_email(request, user) # return redirect(settings.LOGIN_URL) else: form = SignupForm2() return render(request, 'accounts/signup.html', { 'form': form, })
def login(request): """ Log the user in. If successful, let the client handle the redirect. If login fails, return a JSON response indicating failure, along with the rendered html of the bound login form. """ if request.user.is_authenticated() or request.method != 'POST': return {'success': True, 'redirect': reverse('overview')} form = LoginForm(request.POST) t = loader.get_template('login_modal.html') if not form.is_valid(): c = RequestContext(request, {'login_form': form, 'form_only': True}) form_html = t.render(c) return {'success': False, 'form_html': form_html} user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password']) if not user: c = RequestContext(request, {'login_form': form, 'form_only': True, 'extra_errors': ['Invalid password.']}) form_html = t.render(c) return {'success': False, 'form_html': form_html} auth_login(request, user) return {'success': True, 'redirect': reverse('overview')}
def register(request): if request.user.is_authenticated(): return HttpResponseRedirect("/login") next = request.REQUEST.get('next', '') if request.method == 'POST': form = NewUserForm(request.POST) if form.is_valid(): new_user = form.save() user = authenticate(email=form.cleaned_data['email'], password=form.cleaned_data['password1']) auth_login(request, user) UserProfile(id=user.id).assign_slug().save() if "noredirect" in request.POST: return HttpResponse("ok") else: next = request.POST.get("next", "/") + "?welcome=to-sefaria" return HttpResponseRedirect(next) else: form = NewUserForm() return render_to_response("registration/register.html", {'form' : form, 'next': next}, RequestContext(request))
def register(request): """ Register a new user. If successful, log the user in and let the client handle the redirect. If registration fails, return a JSON response indicating failure, along with the rendered html of the bound registration form. """ if request.user.is_authenticated() or request.method != 'POST': return {'success': True, 'redirect': reverse('overview')} form = RegistrationForm(request.POST) t = loader.get_template('registration_modal.html') c = RequestContext(request, {'registration_form': form, 'form_only': True}) form_html = t.render(c) if not form.is_valid(): return {'success': False, 'form_html': form_html} # setup our new user and user profile user = User.objects.create_user(username=form.cleaned_data['username'], email=form.cleaned_data['email'], password=form.cleaned_data['password1']) user.save() user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password1']) auth_login(request, user) return {'success': True, 'redirect': reverse('overview')}
def login(request): if request.method != u'POST': communities = Community.objects.all() response_data = random_captcha() response_data['communities'] = communities return render_to_response('login.html', response_data) else: captcha_list = CaptchaStore.objects.filter(hashkey=request.POST.get(u'cptch_key', None)) communities = Community.objects.all() if len(captcha_list) == 0: response_data = random_captcha() response_data['communities'] = communities response_data['captcha_info'] = u'验证码不正确.' return render_to_response('login.html', response_data) result = captcha_list[0].response verify_code = request.POST.get(u'verify_code', None) if result != verify_code: response_data = random_captcha() response_data['communities'] = communities response_data['captcha_info'] = u'验证码不正确.' return render_to_response('login.html', response_data) username = request.POST.get(u'username', None) password = request.POST.get(u'password', None) if username and password: user = authenticate(username=username, password=password) if user is not None and user.is_active: auth_login(request, user) if not request.POST.get(u'remember_me', None): request.session.set_expiry(0) return redirect(index) else: response_data = random_captcha() response_data['communities'] = communities response_data['password_info'] = u'手机号码、账号或密码错误.' return render_to_response('login.html', response_data)
def login_check_view(request): """ Checks login authentication result and gives failure alert if unsuccessful :param request: user request :return: renders a page with context """ username = request.POST.get(USERNAME) password = request.POST.get(PASSWORD) # Authenticate the user with the provided username and password. # Django authentication is used here. user = authenticate(username=username, password=password) if user is not None: if user.is_active: # Authentication successful auth_login(request, user) return HttpResponseRedirect(reverse(SERVICE_USER_SETUP)) else: # Authentication failure as user was disabled. # Creating respective alerts. set_alert_session(session=request.session, message="This account has been disabled. Contact the admin.", alert_type=DANGER) return HttpResponseRedirect(reverse(SERVICE_MAIN_HOME)) else: # Authentication failure # the authentication system was unable to verify the username and password set_alert_session(session=request.session, message="The username or password were incorrect.", alert_type=DANGER) return HttpResponseRedirect(reverse(SERVICE_MAIN_HOME))
def login_helper(request, email, password): """Determines whether email password pair exists. Login helper function to check that email password pair exists and is active. Args: request: Django's HttpRequest object that contains metadata. https://docs.djangoproject.com/en/dev/ref/request-response/ email: Email adress supplied to login form. pssword: Password supplied to login form. Returns: ret: Boolean that is "False" if user doesn't exist or isn't active, however only "True" if email password is exists and is active. Raises: None. """ ret = False user = authenticate(email=email, password=password) if user: if user.is_active: auth_login(request, user) ret = True return ret
def preview_login(request, course_prefix, course_suffix): """ Login to c2g in preview mode """ login_form = AuthenticationForm(data=request.POST) if login_form.is_valid(): auth_login(request, login_form.get_user()) if not request.common_page_data['course'].preview_only_mode and \ date.today() >= request.common_page_data['course'].calendar_start : redirect_to = 'courses.views.main' else: redirect_to = 'courses.preview.views.preview' return redirect(reverse(redirect_to, args=[course_prefix, course_suffix])) else: form = form_class(initial={'course_prefix':course_prefix,'course_suffix':course_suffix}) context = RequestContext(request) # default template, unless there is one in the soruce tree, then use that template_name='previews/default.html' class_template='previews/'+request.common_page_data['course'].handle+'.html' dirs = getattr(settings,'TEMPLATE_DIRS', []) for dir in dirs: if os.path.isfile(dir+'/'+class_template): template_name=class_template return render_to_response(template_name, {'form': form, 'login_form': login_form, 'common_page_data': request.common_page_data, 'display_login': True}, context_instance=context)
def register_action(request): form = RegisterForm(request.POST) if form.is_valid(): data = form.cleaned_data if request.META.has_key('HTTP_X_FORWARDED_FOR'): ip = request.META['HTTP_X_FORWARDED_FOR'] else: ip = request.META['REMOTE_ADDR'] time_now = datetime.now() username = data['username'] nickname = data['nickname'] password = data['password'] email = data['email'] user_profile_ip = UserProfile.objects.filter(ip=ip).order_by('-time') if len(user_profile_ip) == 0 or time_now - user_profile_ip[0].time > timedelta(days=1): user = User.objects.create_user(username=username, password=password, email=email) if user is not None: user_profile = UserProfile.objects.create(user=user, ip=ip, time=time_now, nickname=nickname) user.save() user_profile.save() user = authenticate(username=username, password=password) auth_login(request, user) return render_to_response('result.jinja', {'state':'1', 'message':u'注册成功', 'url':'/'}, RequestContext(request)) else: return render_to_response('result.jinja', {'state':'2', 'message':u'当前用户名已存在', 'url':'/account/register'}, RequestContext(request)) else: return render_to_response('result.jinja', {'state':'2', 'message':u'相同ip24小时只能注册一次', 'url':'/account/register'}, RequestContext(request)) else: for field in form: if field.errors: return render_to_response('result.jinja', {'state':'2', 'message':field.errors, 'url':'/account/register'}, RequestContext(request))
def login(request): rtn_dict = {'success': False, "msg": ""} login_failed = False if request.method == "POST": username = request.POST.get('username') password = request.POST.get('password') user = authenticate(username=username, password=password) if user is not None: if user.is_active: auth_login(request, user) else: return HttpResponseForbidden(\ content='Your account is not active.') status = 200 else: login_failed = True status = 401 try: account = Account.objects.get(user=user) rtn_dict['userid'] = account.id except Exception as e: print 'Unable to get account for user id {0}'.format(e) logger.info('Unable to get account for user id {0}'.format(e)) return HttpResponse(json.dumps(rtn_dict, cls=DjangoJSONEncoder), content_type="application/json", status=status) return HttpResponse(json.dumps(rtn_dict, cls=DjangoJSONEncoder), content_type="application/json")
def register_user(self, form): """ Create a user instance and send a new registration email (if configured to). """ user = form.save() if getattr(settings, 'OSCAR_SEND_REGISTRATION_EMAIL', True): self.send_registration_email(user) # Raise signal user_registered.send_robust(sender=self, user=user) # We have to authenticate before login try: user = authenticate( username=user.email, password=form.cleaned_data['password1']) except User.MultipleObjectsReturned: # Handle race condition where the registration request is made # multiple times in quick succession. This leads to both requests # passing the uniqueness check and creating users (as the first one # hasn't committed when the second one runs the check). We retain # the first one and delete the dupes. users = User.objects.filter(email=user.email) user = users[0] for u in users[1:]: u.delete() auth_login(self.request, user) return user
def loginajax(request): """ 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(): 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. auth_login(request, form.get_user()) if request.session.test_cookie_worked(): request.session.delete_test_cookie() login_output = {"status": True, "redirect_to": redirect_to} return HttpResponse(simplejson.dumps(login_output)) else: login_output = {"status": False, "error": "Could not find matching user."} return HttpResponse(simplejson.dumps(login_output)) else: # return HttpResponse("not ajax") form = AuthenticationForm(request, label_suffix="") return render_to_response("accounts/login.html", {"form": form}, context_instance=RequestContext(request))
def create_new_customer(request): if request.method == "POST": email = request.POST.get('email') password = request.POST.get('password') passwordConfirm = request.POST.get('passwordConfirm') name = request.POST.get('name') new_user = User.objects.create_user(username=email, email=email, password=password) new_user.save() new_user_profile = CustomerProfile.objects.create(customer=new_user, name=name) new_user_profile.save() user = authenticate(username=email, password=password) if user is not None: if user.is_active: auth_login(request, user) request.session.set_expiry(3600); print(request.session.get_expiry_age()); print(request.session.get_expiry_date()); print(request.session.get_expire_at_browser_close()); return redirect('customer:dashboard') else: return redirect('customer:home') return redirect('customer:dashboard') return render(request, "customer/create_new_customer.html")
def login(request): login_form = LoginForm(request.POST or None) signup_form = SignUpForm(request.POST or None) if request.method == 'POST': print(request.POST) if login_form.is_valid(): username = login_form.cleaned_data.get("username") password = login_form.cleaned_data.get("password") user = authenticate(username=username, password=password) if user is not None: if user.is_active: auth_login(request, user) messages.success(request, "You have been securely logged in") return redirect("home-page") else: messages.success(request, "The password is valid, but the account has been disabled!" " Please contact Tom (+91 999 50 600 98) or mail : [email protected]") return redirect("mylogin") else: messages.success(request, "The username and password were incorrect.") return redirect("mylogin") else: messages.success(request, "The username and password were invalid.") return redirect("mylogin") context = {"Form": login_form, "SignUpForm": signup_form } return render(request, 'login.html', context)
def login_complete(request, redirect_field_name=REDIRECT_FIELD_NAME, render_failure=None): redirect_to = get_query_dict(request).get(redirect_field_name, '') render_failure = ( render_failure or getattr(settings, 'OPENID_RENDER_FAILURE', None) or default_render_failure) openid_response = parse_openid_response(request) if not openid_response: return render_failure( request, 'This is an OpenID relying party endpoint.') if openid_response.status == SUCCESS: try: user = authenticate(openid_response=openid_response) except DjangoOpenIDException, e: return render_failure(request, e.message, exception=e) if user is not None: if user.is_active: auth_login(request, user) response = HttpResponseRedirect( sanitise_redirect_url(redirect_to)) # Notify any listeners that we successfully logged in. openid_login_complete.send( sender=UserOpenID, request=request, openid_response=openid_response) return response else: return render_failure(request, 'Disabled account') else: return render_failure(request, 'Unknown user')
def login(request): ''' Small wrapper around the django login view ''' context = {} if request.REQUEST.get('next'): context['next'] = request.REQUEST.get('next') # Sane login, with POST if request.method == "POST": return django_loginview(request, template_name='user/login.html', extra_context=context) # log in with GET parameters so users can easily get in by scanning a QR code elif request.REQUEST.get('get_login'): form = AuthenticationForm(request, data=request.GET) if form.is_valid(): auth_login(request, form.get_user()) return HttpResponseRedirect(reverse('oracle:dashboard')) return django_loginview(request, template_name='user/login.html', extra_context=context)
def login(request, template_name='cas/login.html', \ success_redirect=settings.LOGIN_REDIRECT_URL, warn_template_name='cas/warn.html'): service = request.GET.get('service', None) if request.user.is_authenticated(): if service is not None: if request.GET.get('warn', False): return render_to_response(warn_template_name, { 'service': service, 'warn': False }, context_instance=RequestContext(request)) ticket = ServiceTicket.objects.create(service=service, user=request.user) return HttpResponseRedirect(ticket.get_redirect_url()) else: return HttpResponseRedirect(success_redirect) if request.method == 'POST': form = LoginForm(request.POST) if form.is_valid(): user = form.get_user() auth_login(request, user) service = form.cleaned_data.get('service') if service is not None: ticket = ServiceTicket.objects.create(service=service, user=user) success_redirect = ticket.get_redirect_url() return HttpResponseRedirect(success_redirect) else: form = LoginForm(initial={ 'service': service, 'lt': LoginTicket.objects.create() }) return render_to_response(template_name, { 'form': form, }, context_instance=RequestContext(request))
def register(request): """ User registration. """ user = request.user if request.method == "POST": form = UserCreationForm(request.POST) if form.is_valid(): new_user = form.save() # Login as the new user if new_user.is_active: username = form.cleaned_data["username"] password = form.cleaned_data["password1"] user = authenticate(username=username, password=password) auth_login(request, user) return redirect(reverse("home")) else: form = UserCreationForm() return render("register.html", {"form":form, "is_logged_in":user.is_authenticated()}, request)
def login(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME, authentication_form=LoginForm, current_app=None, extra_context=None): redirect_to = request.REQUEST.get(redirect_field_name, '') if request.method == "POST": form = authentication_form(request, data=request.POST) if form.is_valid(): # Ensure the user-originating redirection url is safe. if not is_safe_url(url=redirect_to, host=request.get_host()): redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL) # Okay, security check complete. Log the user in. auth_login(request, form.get_user()) return HttpResponseRedirect(redirect_to) else: form = authentication_form(request) 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 guest_login(request, user_id=0): ''' editor: kamihati 2015/6/17 修改逻辑使支持使用user_id登录 :param request: :param user_id: :return: ''' from library.models import Library host = request.get_host() try: print 'guest_login...' library = Library.objects.get(host=host) print 'library_id=', library.id except: # 本地 if host.find("8000") > -1: library = Library.objects.get(pk=3) else: return FailResponse(u"不存在的机构请求") if user_id != 0: # 当用户使用user_id登录 user = AuthUser.objects.filter(pk=user_id) if not user: return FailResponse(u'用户不存在') user = user[0] try: auth_login(request, user) except Exception, e: print 'guest_login %s error:' % user_id print e request.session["is_logon"] = True return SuccessResponse(user_data(user))
def register(request): """ Render and process a basic registration form. """ if not settings.PRETIX_REGISTRATION: raise PermissionDenied('Registration is disabled') ctx = {} if request.user.is_authenticated: return redirect(request.GET.get("next", 'control:index')) if request.method == 'POST': form = RegistrationForm(data=request.POST) if form.is_valid(): user = User.objects.create_user( form.cleaned_data['email'], form.cleaned_data['password'], locale=request.LANGUAGE_CODE, timezone=request.timezone if hasattr(request, 'timezone') else settings.TIME_ZONE ) user = authenticate(request=request, email=user.email, password=form.cleaned_data['password']) user.log_action('pretix.control.auth.user.created', user=user) auth_login(request, user) request.session['pretix_auth_login_time'] = int(time.time()) request.session['pretix_auth_long_session'] = ( settings.PRETIX_LONG_SESSIONS and form.cleaned_data.get('keep_logged_in', False) ) return redirect('control:index') else: form = RegistrationForm() ctx['form'] = form return render(request, 'pretixcontrol/auth/register.html', ctx)
def login(request): """ Render and process a most basic login form. Takes an URL as GET parameter "next" for redirection after successful login """ ctx = {} if request.user.is_authenticated: return redirect(request.GET.get("next", 'control:index')) if request.method == 'POST': form = LoginForm(data=request.POST) if form.is_valid() and form.user_cache: request.session['pretix_auth_long_session'] = ( settings.PRETIX_LONG_SESSIONS and form.cleaned_data.get('keep_logged_in', False) ) if form.user_cache.require_2fa: request.session['pretix_auth_2fa_user'] = form.user_cache.pk request.session['pretix_auth_2fa_time'] = str(int(time.time())) twofa_url = reverse('control:auth.login.2fa') if "next" in request.GET and is_safe_url(request.GET.get("next"), allowed_hosts=None): twofa_url += '?next=' + quote(request.GET.get('next')) return redirect(twofa_url) else: auth_login(request, form.user_cache) request.session['pretix_auth_login_time'] = int(time.time()) if "next" in request.GET and is_safe_url(request.GET.get("next"), allowed_hosts=None): return redirect(request.GET.get("next")) return redirect(reverse('control:index')) else: form = LoginForm() ctx['form'] = form ctx['can_register'] = settings.PRETIX_REGISTRATION ctx['can_reset'] = settings.PRETIX_PASSWORD_RESET return render(request, 'pretixcontrol/auth/login.html', ctx)
def signup(request, template="accounts/account_signup.html", extra_context=None): """ Signup form. """ #Staat in admin_forms form = NewUserCreationForm(request.POST or None, request.FILES or None) if request.method == "POST" and form.is_valid(): new_user = form.save() if not new_user.is_active: if settings.ACCOUNTS_APPROVAL_REQUIRED: send_approve_mail(request, new_user) info(request, _("Thanks for signing up! You'll receive " "an email when your account is activated.")) else: send_verification_mail(request, new_user, "signup_verify") info(request, _("A verification email has been sent with " "a link for activating your account.")) return redirect(next_url(request) or "/") else: info(request, _("Successfully signed up")) auth_login(request, new_user) return login_redirect(request) context = {"form": form, "title": _("Sign up")} context.update(extra_context or {}) return render(request, template, context)
def login_validate(request,username,password): rtvalue = False user = authenticate(username=username,password=password) if user is not None: auth_login(request,user) return True return rtvalue
def create_account(request): error=None form = CreateUserForm() if request.method=='POST': form = CreateUserForm(request.POST) if form.is_valid(): data = form.cleaned_data try: check_user = User.objects.get(username=data.get('username')) error = "User with username: "******" already exists." except User.DoesNotExist: if data.get('password') != data.get('verify_password'): error= "Passwords do not match." else: user = User() user.username=data.get('username') user.set_password(data.get('password')) user.email=data.get('email') user.save() squirl=Squirl() squirl.squirl_user=user squirl.save() auth_user = authenticate(username=data.get('username'), password=data.get('password')) auth_login(request, auth_user) return redirect(index) else: error = "Try Again" return render(request, 'squirl/createAccount.html', {'form': form, 'error': error})
def register_loginza_user(uid, provider, defaults, request): """ Register user in the system from Loginza OpenID :rtype: Profile """ # Check if user already exists but uses different OpenID if 'email' in defaults: try: user = Profile.objects.get(email=defaults['email']) except Profile.DoesNotExist: pass else: user = authenticate(email=user.email) auth_login(request, user) return user user, created = Profile.objects.get_or_create(uid=uid, provider=provider, is_active=True, defaults=defaults) if created: user.set_unusable_password() user.save() transfer_objects(request.user, user) user = authenticate(uid=uid, provider=provider) if user.is_active: auth_login(request, user) return user
def post(self, request, *args, **kwargs): token = request.POST.get('token', '').strip().replace(' ', '') valid = False if '_u2f_challenge' in self.request.session and token.startswith('{'): devices = [DeviceRegistration.wrap(device.json_data) for device in U2FDevice.objects.filter(confirmed=True, user=self.user)] challenge = self.request.session.pop('_u2f_challenge') try: u2f.verify_authenticate(devices, challenge, token, [self.app_id]) valid = True except Exception: logger.exception('U2F login failed') else: valid = match_token(self.user, token) if valid: auth_login(request, self.user) request.session['pretix_auth_login_time'] = int(time.time()) del request.session['pretix_auth_2fa_user'] del request.session['pretix_auth_2fa_time'] if "next" in request.GET and is_safe_url(request.GET.get("next"), allowed_hosts=None): return redirect(request.GET.get("next")) return redirect(reverse('control:index')) else: messages.error(request, _('Invalid code, please try again.')) return redirect('control:auth.login.2fa')
def is_authenticated(self, request): """ if user is_authenticated: return True else try to authenticate with django and return true/false dependent of result """ # is authenticated if request.user.is_authenticated(): return True # not authenticated, call authentication form f = AuthenticationForm(data={ 'username': request.REQUEST.get('username',''), 'password': request.REQUEST.get('password',''), }) # if authenticated log the user in. if f.is_valid(): auth_login(request, f.get_user()) # this ** should ** return true return request.user.is_authenticated() else: # fail to auth, save form errors #self.errors = f.errors return False
def user_creation(request): if request.user.is_authenticated(): return redirect('common:dashboard') user_create_form = forms.UserCreateForm(data=request.POST or None) if request.POST and user_create_form.is_valid(): user = user_create_form.save() user = authenticate( username=request.POST['username'], password=request.POST['password1']) auth_login(request, user) # In order to create an account they've already done the # first 2 training Tasks task = Task.objects.first() badges.possibly_award_badge('skill_awarded', user=user, level=task.provides_qualification) from django.contrib.contenttypes.models import ContentType from django.utils import timezone content_type = ContentType.objects.get_for_model(task) Point.objects.create(user=request.user, amount=task.points, content_type=content_type, object_id=task.id, created=timezone.now()) UserQuestRelationship.objects.create(task=task, user=user, completed=True) # Redirect them back b/c of the UserProfileForm return redirect('registration:user_creation_settings') return TemplateResponse(request, 'registration/create.jade', {'form': user_create_form})
def ldap_login(request, course_prefix, course_suffix): #check if there is valid remote user. #if one exists, try to match them #if one does not exist, create it and assign to proper institution #then redirect #setup the redirect first: code borrowed from django contrib library redir_to = request.GET.get('next', '/') netloc = urlparse.urlparse(redir_to)[1] # Heavier security check -- don't allow redirection to a different # host. if netloc and netloc != request.get_host(): redir_to = '/' # check if username exists to find out what type of user # this ensures that we don't unecessarily do the ldap auth is_institution_logon = False user_exists = False username = request.POST['username'] password = request.POST['password'] user_exists = User.objects.filter(username=username).exists() if user_exists: user = User.objects.get(username=username) is_institution_logon = user.get_profile().site_data == "UWA" result = 'error' # Check if can be internal i.e. numeric if is_number(request.POST['username']): client = SoapClient( wsdl="https://www.socrates.uwa.edu.au/tisi/commonws.asmx?wsdl", trace=True) response = client.UserAuth(userName=request.POST['username'], password=request.POST['password']) result = response['UserAuthResult'] if 'error' in result: ''' Now try and do regular auth ''' form = AuthenticationForm(data=request.POST) if form.is_valid(): auth_login(request, form.get_user()) return HttpResponseRedirect(redir_to) else: # messages.add_message(request,messages.ERROR, 'Error with Username or Password') extra_context = {} context = RequestContext(request) for key, value in extra_context.items(): context[key] = callable(value) and value() or value layout = {'m': 800} return render_to_response('registration/login.html', { 'form': form, 'next': request.GET.get('next', '/') }, context_instance=context) #return render_to_response('registration/login.html', # {'form': form, 'layout': json.dumps(layout)}, # context_instance=context) ldapUser = json.loads(result) if not User.objects.filter(username=request.POST['username']).exists(): #here, we need to create the new user ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" rg = random.SystemRandom(random.randint(0, 100000)) password = (''.join(rg.choice(ALPHABET) for i in range( 16))) + '1' #create a random password, which they will never use User.objects.create_user(username, ldapUser[0]['mail'], password) User.objects.create_user # authenticate() always has to be called before login(), and # will return the user we just created. new_user = auth_authenticate(username=username, password=password) new_user.first_name, new_user.last_name = ldapUser[0][ 'givenname'].capitalize(), ldapUser[0]['sn'].capitalize() new_user.save() print new_user profile = new_user.get_profile() profile.site_data = 'UWA' profile.institutions.add(Institution.objects.get(title='UWA')) profile.save() auth_login(request, new_user) signals.user_registered.send(sender=__file__, user=new_user, request=request) return HttpResponseRedirect( request.GET.get('next', '/accounts/profile')) else: #User already exists, so log him/her in user = User.objects.get(username=username) user.backend = 'django.contrib.auth.backends.ModelBackend' auth_login(request, user) messages.add_message(request, messages.SUCCESS, 'You have successfully logged in!') return HttpResponseRedirect(redir_to)
def shib_login(request): #check if there is valid remote user. #if one exists, try to match them #if one does not exist, create it and assign to proper institution #then redirect #setup the redirect first: code borrowed from django contrib library redir_to = request.GET.get('next', '/accounts/profile') netloc = urlparse.urlparse(redir_to)[1] # Heavier security check -- don't allow redirection to a different # host. if netloc and netloc != request.get_host(): redir_to = '/accounts/profile' #Use EduPersonPrincipalName http://www.incommonfederation.org/attributesummary.html#eduPersonPrincipal #as username in our system. We could support other persistent identifiers later, but it will take some #work if ('REMOTE_USER' in request.META) and ('eppn' in request.META) and ( request.META['REMOTE_USER'] == request.META['eppn']) and request.META['eppn']: #if we get here, the user has authenticated properly shib = { 'givenName': '', 'sn': '', 'mail': '', 'affiliation': '', 'Shib-Identity-Provider': '', } shib.update(request.META) #Clean up first name, last name, and email address shib['sn'] = string.split(shib['sn'], ";")[0] shib['givenName'] = string.split(shib['givenName'], ";")[0] if not shib['mail']: shib['mail'] = shib['eppn'] if not User.objects.filter(username=shib['REMOTE_USER']).exists(): #here, we need to create the new user ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" rg = random.SystemRandom(random.randint(0, 100000)) password = (''.join( rg.choice(ALPHABET) for i in range(16) )) + '1' #create a random password, which they will never use User.objects.create_user(shib['REMOTE_USER'], shib['mail'], password) # authenticate() always has to be called before login(), and # will return the user we just created. new_user = auth_authenticate(username=shib['REMOTE_USER'], password=password) new_user.first_name, new_user.last_name = shib[ 'givenName'].capitalize(), shib['sn'].capitalize() new_user.save() profile = new_user.get_profile() profile.site_data = shib['affiliation'] if 'stanford.edu' in shib['affiliation']: profile.institutions.add( Institution.objects.get(title='Stanford')) profile.save() auth_login(request, new_user) signals.user_registered.send(sender=__file__, user=new_user, request=request) else: #User already exists, so log him/her in user = User.objects.get(username=shib['REMOTE_USER']) user.backend = 'django.contrib.auth.backends.ModelBackend' auth_login(request, user) messages.add_message(request, messages.SUCCESS, 'You have successfully logged in!') else: messages.add_message( request, messages.ERROR, 'WebAuth did not return your identity to us! Please try logging in again. If the problem continues please contact [email protected]' ) return HttpResponseRedirect(redir_to)
def login(request, next_page=None, required=False): """Forwards to CAS login URL or verifies CAS ticket""" service_url = get_service_url(request, next_page) client = get_cas_client(request=request, service_url=service_url) if not next_page and settings.CAS_STORE_NEXT and 'CASNEXT' in request.session: next_page = request.session['CASNEXT'] del request.session['CASNEXT'] if not next_page: next_page = get_redirect_url(request) if request.method == 'POST' and request.POST.get('logoutRequest'): clean_sessions(client, request) return HttpResponseRedirect(next_page) if request.user.is_authenticated(): if settings.CAS_LOGGED_MSG is not None: message = settings.CAS_LOGGED_MSG % request.user.get_username() messages.success(request, message) return HttpResponseRedirect(next_page) ticket = request.GET.get('ticket') if ticket: user = authenticate(ticket=ticket, service=service_url, request=request) pgtiou = request.session.get("pgtiou") if user is not None: if not request.session.exists(request.session.session_key): request.session.create() auth_login(request, user) SessionTicket.objects.create( session_key=request.session.session_key, ticket=ticket ) if pgtiou and settings.CAS_PROXY_CALLBACK: # Delete old PGT ProxyGrantingTicket.objects.filter( user=user, session_key=request.session.session_key ).delete() # Set new PGT ticket try: pgt = ProxyGrantingTicket.objects.get(pgtiou=pgtiou) pgt.user = user pgt.session_key = request.session.session_key pgt.save() except ProxyGrantingTicket.DoesNotExist: pass if settings.CAS_LOGIN_MSG is not None: name = user.get_username() message = settings.CAS_LOGIN_MSG % name messages.success(request, message) return HttpResponseRedirect(next_page) elif settings.CAS_RETRY_LOGIN or required: return HttpResponseRedirect(client.get_login_url()) else: raise PermissionDenied(_('Login failed.')) else: if settings.CAS_STORE_NEXT: request.session['CASNEXT'] = next_page return HttpResponseRedirect(client.get_login_url())
def login(request): if request.user.is_authenticated(): return redirect('index') if request.method == 'POST': token = request.POST.get('token', None) username = request.POST.get('username', None) password = request.POST.get('password', None) if token is not None: otpdigit1 = request.POST.get('otpdigit1', '') otpdigit2 = request.POST.get('otpdigit2', '') otpdigit3 = request.POST.get('otpdigit3', '') otpdigit4 = request.POST.get('otpdigit4', '') otp = otpdigit1 + otpdigit2 + otpdigit3 + otpdigit4 if len(otp) == 4: ua = UnauthenticatedSession.objects.get(token=str(token)) if ua.guesses_left > 0: if ua.successful == False: if otp == ua.otp: ua.successful = True ua.save() auth_login(request, ua.user) return redirect('index') else: ua.guesses_left -= 1 ua.save() return render( request, "2ndfactor.html", { 'error': "The entered code was incorrect.", 'token': token }) else: return render(request, "2ndfactor.html", { 'error': "Token has already been used.", }) else: return render( request, "2ndfactor.html", { 'error': "Code has been entered incorrectly too many times.", }) else: return render(request, "2ndfactor.html", {'error': True}) elif username and password: user = auth_authenticate(request, username=username, password=password) if user is not None: token = str(uuid4()) otp = str(randint(1111, 9999)) gwapi = OAuth1Session( os.environ['VICTORY_GATEWAYAPI_KEY'], client_secret=os.environ['VICTORY_GATEWAYAPI_SECRET']) req = { 'message': 'Victory login code:\n{} {} {} {}'.format( otp[0:1], otp[1:2], otp[2:3], otp[3:4]), 'recipients': [{ 'msisdn': user.extendeduser.phone_number[1:] }], 'destaddr': 'DISPLAY', 'sender': 'VICTORY', } res = gwapi.post('https://gatewayapi.com/rest/mtsms', json=req) res.raise_for_status() us = UnauthenticatedSession() us.user = user us.token = token us.otp = otp us.save() return render(request, "2ndfactor.html", {'token': token}) else: return render(request, "login.html", {'invalid': True}) else: return render(request, "login.html") else: return render(request, 'login.html')
def form_valid(self, form): user = form.save() auth_login(self.request, user) return redirect(self.get_success_url())
def post(self, request, *args, **kwargs): auth_login(self.request, request.user) return Response()
def ldap_preview_login(request, course_prefix, course_suffix): # check if username exists to find out what type of user # this ensures that we don't unecessarily do the ldap auth is_institution_logon = False user_exists = False username = request.POST['username'] password = request.POST['password'] user_exists = User.objects.filter(username=username).exists() if user_exists: user = User.objects.get(username=username) is_institution_logon = user.get_profile().site_data == "UWA" result = 'error' if is_number(request.POST['username']): client = SoapClient( wsdl="https://www.socrates.uwa.edu.au/tisi/commonws.asmx?wsdl", trace=True) response = client.UserAuth(userName=request.POST['username'], password=request.POST['password']) result = response['UserAuthResult'] if 'error' in result: ''' Now try and do regular auth ''' login_form = AuthenticationForm(data=request.POST) if login_form.is_valid(): auth_login(request, login_form.get_user()) if not request.common_page_data['course'].preview_only_mode and \ date.today() >= request.common_page_data['course'].calendar_start : redirect_to = 'courses.views.main' else: redirect_to = 'courses.preview.views.preview' return redirect( reverse(redirect_to, args=[course_prefix, course_suffix])) else: form_class = RegistrationFormUniqueEmail form = form_class(initial={ 'course_prefix': course_prefix, 'course_suffix': course_suffix }) context = RequestContext(request) try: video = Video.objects.getByCourse( course=request.common_page_data['course']).get( slug='intro') except Video.DoesNotExist: video = None course_instructors = CourseInstructor.objects.getByCourse( course=request.common_page_data['course']) instructors = [] for ci in course_instructors: instructors.append(ci.instructor) template_name = 'previews/default.html' return render_to_response( template_name, { 'form': form, 'login_form': login_form, 'video': video, 'instructors': instructors, 'common_page_data': request.common_page_data, 'course': request.common_page_data['course'], 'display_login': True }, context_instance=context) ldapUser = json.loads(result) if not User.objects.filter(username=request.POST['username']).exists(): #here, we need to create the new user ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" rg = random.SystemRandom(random.randint(0, 100000)) password = (''.join(rg.choice(ALPHABET) for i in range( 16))) + '1' #create a random password, which they will never use User.objects.create_user(username, ldapUser[0]['mail'], password) User.objects.create_user # authenticate() always has to be called before login(), and # will return the user we just created. new_user = auth_authenticate(username=username, password=password) new_user.first_name, new_user.last_name = ldapUser[0][ 'givenname'].capitalize(), ldapUser[0]['sn'].capitalize() new_user.save() print new_user profile = new_user.get_profile() profile.site_data = 'UWA' profile.institutions.add(Institution.objects.get(title='UWA')) profile.save() auth_login(request, new_user) signals.user_registered.send(sender=__file__, user=new_user, request=request) # return HttpResponseRedirect(request.GET.get('next', '/accounts/profile')) else: #User already exists, so log him/her in user = User.objects.get(username=username) user.backend = 'django.contrib.auth.backends.ModelBackend' auth_login(request, user) # messages.add_message(request,messages.SUCCESS, 'You have successfully logged in!') if not request.common_page_data['course'].preview_only_mode and \ date.today() >= request.common_page_data['course'].calendar_start : redirect_to = 'courses.views.main' else: redirect_to = 'courses.preview.views.preview' return redirect(reverse(redirect_to, args=[course_prefix, course_suffix]))
def registration(request): """ Navigates to the registration page. POST will create a user and log in, GET will display the form. **Context** ``message`` An error message in the event that something is incorrect. ``next`` The redirect page upon successfull login. **Template** :template:`registration/registration.html` """ if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): user = User.objects.create_user(form.cleaned_data['username'], form.cleaned_data['email'], form.cleaned_data['password']) #user.is_active = False user.save() user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password']) next = request.POST.get('next', "/") if user is not None: if user.is_active: auth_login(request, user) # Redirect to a success page. return redirect(next) """activation = Activation(username=user.username, time=datetime.datetime.now()) activation.save() if user is not None: subject, from_email, to_email = "CEOS Datacube Account Activation", "*****@*****.**", [user.email] msg = EmailMessage() msg['From'] = from_email msg['To'] = to_email msg['Subject'] = subject msg.set_content('') # It is possible to use msg.add_alternative() to add HTML content too html_content = "" activation_url = settings.BASE_HOST + "/accounts/" + str(activation.url) + "/activate" from os import path with open(path.join(settings.BASE_DIR, 'static/assets/media/email_template.html')) as f: for line in f: if (line == "\t\t\tAVAILABLE_TOOLS\n"): for app in Application.objects.all(): html_content += "<li>" + app.application_name + "</li>" elif (line == "\t\t\tAVAILABLE_AREAS\n"): for area in Area.objects.all(): html_content += "<li>" + area.area_name + "</li>" elif ("HOME_URL" in line): html_content += line.replace("HOME_URL", settings.BASE_HOST) else: html_content += line if 'str' in line: break html_content = html_content.replace("ACTIVATION_URL", activation_url) msg.add_alternative(html_content, subtype='html') # Attaching content: fp = open(path.join(settings.BASE_DIR, 'static/assets/media/banner.png'), 'rb') att = MIMEImage(fp.read()) # Or use MIMEImage, etc fp.close() # The following line is to control the filename of the attached file att.add_header('Content-Disposition', 'attachment', filename='banner.png') msg.make_mixed() # This converts the message to multipart/mixed msg.attach(att) # Don't forget to convert the message to multipart first! # Sending the email: with smtplib.SMTP('localhost') as s: s.send_message(msg) form = LoginForm() form.cleaned_data = {} form.add_error(NON_FIELD_ERRORS, _("Activate your account using the url that has been emailed to you and log in.")) context = { 'title': _("Log in"), 'form': form, } return render(request, 'registration/login.html', context)""" context = { 'title': _("Registration"), 'form': form, } return render(request, 'registration/registration.html', context) else: context = {'title': _("Registration"), 'form': RegistrationForm(),} if request.GET: next = request.POST.get('next', "/") if request.user.is_authenticated: return redirect(next) context['next'] = next return render(request, 'registration/registration.html', context)
def login_it(self, user): auth_login(self.request, user) # 如果设置了自动登录,那需要设置 session_id cookie 的有效期 if self.request.session.get('auto_login'): age = self.request.session.get_expiry_age() self.request.session.set_expiry(age)
def callback(request): if request.method == "GET": code = request.GET.get('code') state = request.GET.get("state") # Then if we get a response from Ion with the authorization code if code is not None and state is not None: # We send it back to fetch the acess_token payload = { 'grant_type': 'authorization_code', 'code': code, 'redirect_uri': redirect_uri, 'client_id': client_id, 'client_secret': client_secret, 'csrfmiddlewaretoken': state } token = requests.post("https://ion.tjhsst.edu/oauth/token/", data=payload).json() headers = {'Authorization': f"Bearer {token['access_token']}"} # And finally get the user's profile! profile = requests.get("https://ion.tjhsst.edu/api/profile", headers=headers).json() username = profile['ion_username'] email = profile['tj_email'] first_name = profile['first_name'] last_name = profile['last_name'] # First we need to check if this user is authoized to post, as defined in the global array above if username in authorized_users: # Then we check if this user exists in the system, we log them in, and if not we create a user for them user = authenticate(request, username=username, password=username) if user is not None: auth_login(request, user) messages.success(request, f"Welcome back {first_name}!") else: user = User.objects.create_user(username=username, email=email, password=username, first_name=first_name, last_name=last_name) user.save() auth_login( request, user, backend='django.contrib.auth.backends.ModelBackend') messages.success( request, f"Welcome to Chirper, {first_name}, we hope you enjoy your stay!" ) return redirect('profile') else: messages.error(request, "Sorry, you're not an authorized Ion user!", extra_tags='danger') return redirect('blog-home') messages.warning(request, "Invalid Callback Response") return redirect('blog-home')
def bind_email(request): sex = request.GET.get('sex', request.POST.get('sex', '')) openid = request.GET.get('openid', request.POST.get('openid', '')) nickname = request.GET.get('nickname', request.POST.get('nickname', '')) type = request.GET.get('type', request.POST.get('type', '')) signature = request.GET.get('signature', request.POST.get('signature', '')) image_url = request.GET.get('image_url', request.POST.get('image_url', '')) if request.method == 'POST': froms = BindEmail(request.POST) if froms.is_valid(): openid = froms.cleaned_data['openid'] nickname = froms.cleaned_data['nickname'] type = froms.cleaned_data['type'] signature = froms.cleaned_data['signature'] image_url = froms.cleaned_data['image_url'] sex = froms.cleaned_data['sex'] email = froms.cleaned_data['email'] password = froms.cleaned_data['password'] users = models.User.objects.filter(email=email) if users: user = users[0] else: while models.User.objects.filter(username=nickname): nickname = nickname + '*' user = models.User(username=nickname, email=email, sex=sex, signature=signature) user.password(password) user.is_active = True user.download_image(image_url, nickname) user.save() oauth_ex = models.OAuth_ex(user=user, openid=openid, type=type) oauth_ex.save() auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') data = {} data['goto_page'] = True data['goto_url'] = '/' data['goto_time'] = 10000 data['message_title'] = '绑定成功' data[ 'message'] = '绑定成功您的用户名为:<b>%s</b>。您现在可以同时使用本站账号和此第三方账号登录本站了!' % nickname return render_to_response('Login/success.html', data) else: form = BindEmail( initial={ 'openid': openid, 'nickname': nickname, 'type': type, 'signature': signature, 'image_url': image_url, 'sex': sex }) return render(request, 'Login/bind_email.html', context={ 'form': form, 'nickname': nickname, 'type': type })
def login(request): if request.user.is_authenticated: # if the user is authenticated and has a token remove the token and logout of the session and relogin try: existing_token = AuthToken.objects.get(user=request.user.online_id) existing_token.delete() logout(request) return redirect('main:login') # if the user is authenticated and has no token then go to the dashboard except: return redirect('main:dashboard') else: User = get_user_model() if request.method == 'POST': # login POST request form = LoginForm(request.POST) # generate token key token_key = get_random_string(30) if form.is_valid(): # get login form data form online_id = form.cleaned_data.get('online_id') password = form.cleaned_data.get('password') # authenticate user auth_user = authenticate(online_id=online_id,password=password) if auth_user is not None: if auth_user.is_active: # login the user ''' this should only happen when the user has put the token ''' auth_login(request, auth_user) # get the current user by online id current_usr =request.user.online_id # get the user instance user = User.objects.get(online_id=current_usr) '''Token authentication and error handling''' try: # check if the user has a token then redirect to user_token = AuthToken.objects.get(user=user) user_email = Registration.objects.get(user=user) # token and email auth_token = user_token.token email = user_email.email print(auth_token) time.sleep(30) encode_token_login = jsonpickle.encode(auth_token) encode_email = jsonpickle.encode(email) except: ''' error handlin incase login happened and token was deleted ''' # if token does not exist then create the token and redirect to token auth create_token = AuthToken.objects.create( user=user, token=token_key ) encode_token_login= jsonpickle.encode(token_key) # send the authentication to the user try: # get the users email email = Registration.objects.get( user=user, ).email encode_email = jsonpickle.encode(email) except: messages.error(request, 'You don\'t have your Email With Us.. Contact [email protected] for Help.') print('user has no email') return redirect('main:login') '''email the token to the user''' print(encode_token_login) send_token.delay(3,encode_token_login,encode_email) # redirect return redirect('main:token-auth') else: print('user is inactive') else: print('invalid Username/password') else: return render(request, 'main/login.html', { 'form': form }) else: form = LoginForm() context = { 'form': form } return render(request, 'main/login.html', context)
def form_valid(self, form): """Security check complete. Log the user in.""" auth_login(self.request, form.get_user()) return HttpResponseRedirect(self.get_success_url())
def git_check(request): type = '1' request_code = request.GET.get('code') oauth_git = OAuth_GitHub(settings.GITHUB_APP_ID, settings.GITHUB_CALLBACK_URL) try: access_token = oauth_git.get_access_token(request_code) time.sleep(0.1) except: data = {} data['goto_url'] = '/' data['goto_time'] = 100000 data['goto_page'] = True data['message_title'] = '登录失败' data['message'] = '获取授权失败,请确认是否允许授权,并重试。若问题无法解决,请联系网站管理人员' return render_to_response('', data) infos = oauth_git.get_user_info() # 获取用户信息 nickname = infos.get('login', '') image_url = infos.get('avatar_url') open_id = str(oauth_git.openid) signature = infos.get('bio', '') if not signature: signature = '无标个性签名' sex = '1' githubs = models.OAuth_ex.objects.filter(openid=open_id, type=type) if githubs: auth_login(request, githubs[0].user, backend='django.contrib.auth.backends.ModelBackend') return HttpResponseRedirect('/') else: try: email = oauth_git.get_email() except: url = '' return HttpResponseRedirect(url) users = models.User.objects.filter(email=email) if users: users = users[0] else: while models.User.objects.filter(username=nickname): # 防止用户名重复 nickname = nickname + '*' users = models.User(username=nickname, sex=sex, signature=signature) pwd = str(uuid.uuid1()) # 随机设置用户密码 users.password(pwd) users.is_active = True users.download_image(image_url, nickname) # 下载用户头像图片 users.save() oauth_ex = models.OAuth_ex(user=users, openid=open_id, type=type) oauth_ex.save() # 保存后登录 auth_login(request, users, backend='django.contrib.auth.backends.ModelBackend') data = {} # 登录反馈 data['goto_url'] = '/' data['goto_time'] = 10000 data['goto_page'] = True data['message_title'] = '绑定成功' data['message'] = u'绑定成功,你的用户名:<b>%s</b>,你可以通过第三方账户的登录本站拉' % nickname return render_to_response('Login/success.html', data)
def git_check(request): # pdb.set_trace() type = '1' request_code = request.GET.get('code') oauth_git = OAuth_GITHUB(settings.GITHUB_APP_ID, settings.GITHUB_KEY, settings.GITHUB_CALLBACK_URL) try: access_token = oauth_git.get_access_token( request_code) # 获取access token time.sleep(0.1) # 此处需要休息一下,避免发送urlopen的10060错误 except: # 获取令牌失败,反馈失败信息 data = dict() data['goto_url'] = '/' data['goto_time'] = 10000 data['goto_page'] = True data['message_title'] = '登录失败' data['message'] = '获取授权失败,请确认是否允许授权,并重试。若问题无法解决,请联系网站管理人员' return render_to_response('blog/response.html', data) infos = oauth_git.get_user_info() # 获取用户信息 nickname = infos.get('login', '') image_url = infos.get('avatar_url', '') # oauth_git.openid这样可以直接取到方法中的返回的self.openid open_id = str(oauth_git.openid) signature = infos.get('bio', '') if not signature: signature = "无个性签名" githubs = OAuth_ex.objects.filter(openid=open_id, oauth_type=type) # 查询是否该第三方账户已绑定本网站账号 if githubs: # 若已绑定,直接登录 auth_login(request, githubs[0].user, backend='django.contrib.auth.backends.ModelBackend') return HttpResponseRedirect('/') else: # 否则尝试获取用户邮箱用于绑定账号 try: email = oauth_git.get_email() except: # 若获取失败,则跳转到绑定用户界面,让用户手动输入邮箱 url = "%s?nickname=%s&openid=%s&type=%s&signature=%s&image_url=%s" % ( reverse('user:bind_email'), nickname, open_id, type, signature, image_url) return HttpResponseRedirect(url) users = User.objects.filter(email=email) # 若获取到邮箱,则查询是否存在本站用户 if users: # 若存在,则直接绑定 user = users[0] else: # 若不存在,则新建本站用户 while User.objects.filter(username=nickname): # 防止用户名重复 nickname = nickname + '*' user = User(username=nickname, email=email) pwd = str(uuid.uuid1()) # 随机设置用户密码 user.set_password(pwd) user.is_active = True user.save() oauth_type = OAuth_type.objects.get( id=type) # 找到oauth_type中的对应type的id(可能有多个登录方式,所以有这表) oauth_ex = OAuth_ex(user=user, openid=open_id, oauth_type=oauth_type) oauth_ex.save() # 保存后登陆 auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') data = dict() # 反馈登陆结果 data['goto_url'] = '/' data['goto_time'] = 10000 data['goto_page'] = True data['message_title'] = '绑定用户成功' data['image_url'] = image_url data[ 'message'] = u'绑定成功!您的用户名为:<b>%s</b>。您现在可以同时使用本站账号和此第三方账号登录本站了!' % nickname return render_to_response('blog/response.html', data)
def login(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME, authentication_form=AuthenticationForm, extra_context=None, redirect_authenticated_user=False): """ Displays the login form and handles the login action. """ redirect_to = request.POST.get(redirect_field_name, request.GET.get(redirect_field_name, '')) if redirect_authenticated_user and request.user.is_authenticated: redirect_to = _get_login_redirect_url(request, redirect_to) if redirect_to == request.path: raise ValueError( "Redirection loop for authenticated user detected. Check that " "your LOGIN_REDIRECT_URL doesn't point to a login page.") return HttpResponseRedirect(redirect_to) elif request.method == "POST": form = authentication_form(request, data=request.POST) if form.is_valid(): auth_login(request, form.get_user()) return redirect('frontend:machines') else: # active users without password try: user = User.objects.get(username=request.POST['username']) if user.is_active and not user.password: messages.info(request, "Please receive your inital password.") url = reverse('password_restore') return redirect('{}?user_id={}'.format(url, user.pk)) except Exception: pass messages.error(request, "Unknown login/password!") form = authentication_form(request) else: form = authentication_form(request) current_site = get_current_site(request) context = { 'form': form, redirect_field_name: redirect_to, 'site': current_site, 'site_name': current_site.name, 'title': 'Login' } if extra_context is not None: context.update(extra_context) welcome_message = ServerConfig.objects.by_key('orthos.web.welcomemessage') if welcome_message and len(welcome_message) > 0: messages.info(request, mark_safe(welcome_message)) return TemplateResponse(request, template_name, context)
def get_success_url(self): user = get_user_or_tmp_user(self.request) auth_login(self.request, user) return redirect_user_first_login_or_index(self.request, self.redirect_field_name)
def form_valid(self, form): user = form.save() del self.request.session[INTERNAL_RESET_SESSION_TOKEN] if self.post_reset_login: auth_login(self.request, user, self.post_reset_login_backend) return super().form_valid(form)
def form_valid(self, form): self.object = form.save() # log user in auth_login(self.request, self.object.usermodel_ptr) return HttpResponseRedirect(self.get_success_url())
def bind_email(request): # 使用户手动填写邮箱,绑定本站账号,因此需要一个BindEmail表单 sex = request.GET.get('sex', request.POST.get('sex', '')) openid = request.GET.get('openid', request.POST.get('openid', '')) nickname = request.GET.get('nickname', request.POST.get('nickname', '')) type = request.GET.get('type', request.POST.get('type', '')) signature = request.GET.get('signature', request.POST.get('signature', '')) image_url = request.GET.get('image_url', request.POST.get('image_url', '')) if request.method == 'POST': form = BindEmail(request.POST) if form.is_valid(): openid = form.cleaned_data['openid'] nickname = form.cleaned_data['nickname'] email = form.cleaned_data['email'] password = form.cleaned_data['password'] type = form.cleaned_data['type'] signature = form.cleaned_data['signature'] image_url = form.cleaned_data['image_url'] sex = form.cleaned_data['sex'] users = User.objects.filter(email=email) if users: user = users[0] else: while User.objects.filter(username=nickname): nickname = nickname + '*' user = User(username=nickname, email=email) user.set_password(password) user.is_active = True user.save() oauth_type = OAuth_type.objects.get(id=type) oauth_ex = OAuth_ex(user=user, openid=openid, oauth_type=oauth_type) oauth_ex.save() auth_login(request, user, backend='django.contrib.auth.backends.ModelBackend') data = {} data['goto_url'] = '/' data['goto_time'] = 10000 data['goto_page'] = True data['message_title'] = '绑定账号成功' data[ 'message'] = u'绑定成功!您的用户名为:<b>%s</b>。您现在可以同时使用本站账号和此第三方账号登录本站了!' % nickname return render_to_response('blog/response.html', data) else: form = BindEmail( initial={ 'openid': openid, 'nickname': nickname, 'type': type, 'signature': signature, 'image_url': image_url, 'sex': sex, }) return render(request, 'blog/form.html', context={ 'form': form, 'nickname': nickname, 'type': type })
return wrapper return decorator @rate_limit(num=URLCRYPT_RATE_LIMIT) def login_redirect(request, token): try: decoded_data = decode_login_token(token) except Exception, ex: return HttpResponseRedirect(URLCRYPT_LOGIN_URL) if request.user.is_authenticated( ) and request.user.id == decoded_data['user_id']: return HttpResponseRedirect(decoded_data['url']) user = authenticate(decoded_data=decoded_data) if user: auth_login(request, user) return HttpResponseRedirect(decoded_data['url']) else: return HttpResponseRedirect(URLCRYPT_LOGIN_URL) @login_required def test_view(request, username=None): return HttpResponse("ok") ########NEW FILE########
def wrapper(request, *args, **kwargs): # logger.debug("authenticate %s" % request.user) user = request.user # if logged in if request.user.is_authenticated(): logger.info("user.is_authenticated with user %s" % request.user.username) logger.info("user has internalid: %s" % request.user.authprofile.internalid) return function(request, *args, **kwargs) base = Base.objects.get(user__username=kwargs['username'], name=kwargs['base']) ticket = request.GET.get("ticket", None) if not ticket and (base.public or base.static_public): return function(request, *args, **kwargs) service = reverse( 'userland-static', args=[kwargs['username'], kwargs['base'], "index.html"]) proto = request.META.get('HTTP_X_FORWARDED_PROTO', 'https') host = request.META.get('HTTP_X_FORWARDED_HOST', request.META.get('HTTP_HOST', None)) if base.frontend_host: # if frontend_host is set, we do not want to present the backend uri in the service URL service_full = "%s://%s" % (proto, base.frontend_host) else: service_full = "%s://%s%s" % (proto, host, service) ticket = request.GET.get("ticket", None) if ticket: # if the service is called with a ticket, verify the ticket and redirect to the service cas_ticketverify = reverse('cas-ticketverify') cas_ticketverify += "?ticket=%s&service=%s" % (ticket, service_full) host = urlparse(request.build_absolute_uri()).netloc response = requests.get("https://%s%s" % (host, cas_ticketverify)) logger.info("Response from verify: " + str(response.status_code)) logger.info("Response from verify: " + response.text) # read jwt for identity username, decoded_dict = read_jwt(response.text, settings.SECRET_KEY) logger.info("Identity from Token: %s" % username) logger.info("Identity from Token: %s" % str(decoded_dict)) user = User.objects.get(username=username) user.backend = 'django.contrib.auth.backends.ModelBackend' auth_login(request, user) request.session['cookie_path'] = "/userland/%s/%s" % ( base.user.username, base.name) request.session.cycle_key() # user is logged in successfully, redirect to service URL return HttpResponseRedirect(service) # User need to authenticate first on cas url = reverse('cas-login') + "?service=%s" % service_full logger.info("Redirecting to CAS login %s" % url) return HttpResponseRedirect(url)
def my_login(request, redirect_field_name=REDIRECT_FIELD_NAME, authentication_form=AuthenticationForm): """ Displays the login form and handles the login action. """ logger = tlalogger.dj_mylogger(__file__) logger.debug('Formulario de Login mostrado') #redirect_to = request.REQUEST.get(redirect_field_name, '') redirect_to = request.POST.get(redirect_field_name, '') if request.method == "POST": form = authentication_form(data=request.POST) if form.is_valid(): login_log(request.POST.get('username'), request.META['REMOTE_ADDR'], True) netloc = urlparse.urlparse(redirect_to)[1] # Use default setting if redirect_to is empty if not redirect_to: redirect_to = settings.LOGIN_REDIRECT_URL # Security check -- don't allow redirection to a different # host. elif netloc and netloc != request.get_host(): redirect_to = settings.LOGIN_REDIRECT_URL # No permitir el login desde ips no permitidas: if settings.RESTRINGIR_LOGIN_POR_IP: l_ips_permitidas = list(IPPermitida.objects.all().values_list( 'ip', flat=True)) print l_ips_permitidas if request.META['REMOTE_ADDR'] not in l_ips_permitidas: login_log(request.POST.get('username'), request.META['REMOTE_ADDR'], correcto=True, comentario='IP no permitida') parametros = {'error_msg': "Error 550. No permitido"} return render(request, 'publica/login_error.html', parametros) # Okay, security checks complete. Log the user in. auth_login(request, form.get_user()) if request.session.test_cookie_worked(): request.session.delete_test_cookie() return HttpResponseRedirect(redirect_to) # Por jose (24/09/2012). Esto registra los intentos fallidos else: login_log(request.POST.get('username'), request.META['REMOTE_ADDR'], False) # /jose. else: form = authentication_form(request) request.session.set_test_cookie() #current_site = get_current_site(request) current_site = '' parametros = { 'form': form, redirect_field_name: redirect_to, 'site': '', #current_site, 'site_name': '', #current_site.name, 'servidor_propio': settings.SERVIDOR_PROPIO, } # return render(request, 'publica/login.html', parametros)
def form_valid(self, form): response = super().form_valid(form) user = self.object auth_login(self.request, user) return response
def loginView(request): """Login the user on the system """ if request.method == 'POST': form = LoginForm(request.POST) if form.is_valid(): username = form.cleaned_data['username'] password = form.cleaned_data['password'] next = form.cleaned_data['next'] try: server = form.cleaned_data['host'] config = server_config() host = config.get(server, 'host') port = config.getint(server, 'port') ssl = config.getboolean(server, 'ssl') except: return render_to_response('wpmauth/login.html', { 'form': form, 'error_message': _('Invalid server. '\ 'Please try again.') }, context_instance=RequestContext(request)) try: user = authenticate(username=username[:30], password=password, host=host, port=port, ssl=ssl) except ValueError: return render_to_response('wpmauth/login.html', { 'form': form, 'error_message': _('Invalid login. '\ 'Please try again.') }, context_instance=RequestContext(request)) if user is not None: if user.is_active: auth_login(request, user) # Not an imap user: if (request.session['_auth_user_backend'] == 'django.contrib.auth.backends.ModelBackend'): return render_to_response( 'wpmauth/login.html', { 'form': form, 'error_message': _('This is not an IMAP ' 'valid account. Please try again.') }, context_instance=RequestContext(request)) request.session['username'] = username request.session['password'] = password request.session['host'] = host request.session['port'] = port request.session['ssl'] = ssl return HttpResponseRedirect(next) # Disabled account: else: return render_to_response('wpmauth/login.html', { 'form': form, 'error_message': _('Sorry, disabled ' \ 'account.') }, context_instance=RequestContext(request)) # Invalid user: else: return render_to_response('wpmauth/login.html', { 'form': form, 'error_message': _('Invalid login. Please ' \ 'try again.') }, context_instance=RequestContext(request)) # Invalid form: else: return render_to_response('wpmauth/login.html', {'form': form}, context_instance=RequestContext(request)) # Display the empty form: else: data = {'next': request.GET.get('next', '')} form = LoginForm(data) return render_to_response('wpmauth/login.html', {'form': form}, context_instance=RequestContext(request))
def remember_me_login(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME, authentication_form=AuthenticationRememberMeForm): """ Based on login view cribbed from https://github.com/django/django/blob/1.2.7/django/contrib/auth/views.py#L25 Displays the login form with a remember me checkbox and handles the login action. The authentication_form parameter has been changed from ``django.contrib.auth.forms.AuthenticationForm`` to ``remember_me.forms.AuthenticationRememberMeForm``. To change this, pass a different form class as the ``authentication_form`` parameter. """ redirect_to = request.GET.get(redirect_field_name, '') if request.method == "POST": form = authentication_form(data=request.POST) if form.is_valid(): redirect_to = request.POST.get(redirect_field_name) # Light security check -- make sure redirect_to isn't garbage. if not redirect_to or ' ' in redirect_to: redirect_to = webproject_settings.LOGIN_REDIRECT_URL # Heavier security check -- redirects to http://example.com should # not be allowed, but things like /view/?param=http://example.com # should be allowed. This regex checks if there is a '//' *before* a # question mark. elif '//' in redirect_to and re.match(r'[^\?]*//', redirect_to): redirect_to = webproject_settings.LOGIN_REDIRECT_URL if form.cleaned_data.get('remember_me'): request.session.set_expiry(1209600) # Okay, security checks complete. Log the user in. auth_login(request, form.get_user()) if request.session.test_cookie_worked(): request.session.delete_test_cookie() return HttpResponseRedirect(redirect_to) else: form = authentication_form(request) request.session.set_test_cookie() current_site = get_current_site(request) return render( request, template_name, { 'form': form, 'redirect_field_name': redirect_field_name, 'redirect_field_value': redirect_to, 'site': current_site, 'site_name': current_site.name, })
def form_valid(self, form): self.object = form.get_user() auth_login(self.request, self.object) return super().form_valid(form)
def commit(self, request): auth_login(request, self.user)
def login(request, user): auth_login(request, user) from astakos.im.models import SessionCatalog SessionCatalog(session_key=request.session.session_key, user=user).save() logger.info('%s logged in.', user.log_display)
def form_valid(self, form): username = form.cleaned_data['username'] password = form.cleaned_data['password'] if self.kwargs['role'] == 0: user = authenticate(username=username, password=password) else: teacher = form.cleaned_data['teacher'] user = authenticate(username=teacher+"_"+username, password=password) if user is not None: auth_login(self.request, user) else : return redirect("/account/login/"+str(self.kwargs['role'])) if user.id == 1 and user.first_name == "": user.first_name = "管理員" user.save() # 學習領域 domains = ['生物'] for domain_name in domains: domain = Domain(title=domain_name) domain.save() levels = ['高一','高二','高三'] for level_name in levels: level = Level(title=level_name) level.save() zones = Zone.objects.all() if len(zones) == 0: for city_name, zones, mapx, mapy in county: city = County(name=city_name, mapx=mapx, mapy=mapy) city.save() for zone_name in zones: zone = Zone(name=zone_name, county=city.id) zone.save() school = School(county=2, zone=38, system=3, name="南港高中") school.save() user.last_name = "1" user.save() try : group = Group.objects.get(name="apply") except ObjectDoesNotExist : group = Group(name="apply") group.save() group.user_set.add(user) # create Message title = "請修改您的姓名" url = "/account/realname" message = Message(title=title, url=url, time=timezone.now()) message.save() # message for group member messagepoll = MessagePoll(message_id = message.id,reader_id=1) messagepoll.save() # 記錄訪客資訊 admin_user = User.objects.get(id=1) try: profile = Profile.objects.get(user=admin_user) except ObjectDoesNotExist: profile = Profile(user=admin_user) profile.save() profile.visitor_count = profile.visitor_count + 1 profile.save() year = localtime(timezone.now()).year month = localtime(timezone.now()).month day = localtime(timezone.now()).day date_number = year * 10000 + month*100 + day try: visitor = Visitor.objects.get(date=date_number) except ObjectDoesNotExist: visitor = Visitor(date=date_number) visitor.count = visitor.count + 1 visitor.save() visitorlog = VisitorLog(visitor_id=visitor.id, user_id=user.id, IP=self.request.META.get('REMOTE_ADDR')) visitorlog.save() # If the test cookie worked, go ahead and # delete it since its no longer needed if self.request.session.test_cookie_worked(): self.request.session.delete_test_cookie() return super(Login, self).form_valid(form)