Python LoginForm.is_valid方法代码示例

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
def login_user(request):
    logger.debug("login_user called by user %s" % request.user)
    if request.method == 'POST':
        form = LoginForm(request.POST)
        logger.debug("Request of type POST, received form, valid: %s" % form.is_valid())
        if form.is_valid():
            user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
            logger.debug("Authentication attempt with supplied credentials. Received user %s" % user)
            if user is not None:
                if user.is_active:
                    logger.info("Successful login attempt from user %s" % user)
                    login(request, user)
                    return HttpResponseRedirect("/dashboard")
                else:
                    logger.info("Login attempt failed for user %s: user marked inactive." % user)
            else:
                logger.info("Failed login attempt: provided username %s" % form.cleaned_data['username'])

            return render_to_response('public/login.html', {'form': form, 'error': True},
                                      context_instance=RequestContext(request))
    else:
        logger.debug("Providing new login form.")
        form = LoginForm()

    return render_to_response('public/login.html', {'form': form}, context_instance=RequestContext(request))

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
def list_book(request):
    form = LoginForm()
    if request.method == 'POST':
        form=LoginForm(request.POST.copy())
        if form.is_valid():
            if(True == _login(request,form.cleaned_data["username"],form.cleaned_data["password"])):
                return HttpResponseRedirect('/bookapp/book/list/')

    form = RegisterForm()
    if request.method=="POST":
        form=RegisterForm(request.POST.copy())
        if form.is_valid():
            email = form.cleaned_data["email"]
            username = form.cleaned_data["username"]
            password = form.cleaned_data["password"]
            user=User.objects.create_user(username,email,password)
            user.save()
            _login(request,username,password)#注册完毕 直接登陆
            return HttpResponseRedirect('/bookapp/book/list/')

    form = SearchForm()
    if request.method == 'POST':
        form=SearchForm(request.POST.copy())
        if form.is_valid():
            query = form.cleaned_data["query"]
            search_items = Book.objects.filter(title__contains=query)

            paginator = Paginator(search_items, 10)
            try:
                page = int(request.GET.get('page', '1'))
            except ValueError:
                page = 1
            try:
                search_items = paginator.page(page)
            except :
                search_items = paginator.page(paginator.num_pages)
            t = get_template('bookapp/search_book.html')
            c = RequestContext(request,locals())
            return HttpResponse(t.render(c))
            #search_book(request, query)
            #return HttpResponseRedirect('/bookapp/book/search/',query)

    list_items = Book.objects.all()
    paginator = Paginator(list_items ,10)
    try:
        page = int(request.GET.get('page', '1'))
    except ValueError:
        page = 1

    try:
        list_items = paginator.page(page)
    except :
        list_items = paginator.page(paginator.num_pages)

    t = get_template('bookapp/list_book.html')
    c = RequestContext(request,locals())
    return HttpResponse(t.render(c))

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
 def test_login_form(self):
     
     f = LoginForm(self.user)
     self.assertTrue(f.is_valid(), "username and password are validate")
     self.user["username"] = "1234567890123456789012345678901234567890"
     f = LoginForm(self.user)
     self.assertFalse(f.is_valid(), 'username is too long')
     self.user["password"] = self.user["username"]
     f = LoginForm(self.user)
     self.assertFalse(f.is_valid(), msg = 'password is too long')
     self.user["check_code"] = self.user["username"]
     f = LoginForm(self.user)
     self.assertFalse(f.is_valid(), msg = 'check_code is too long')

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
def login(request):
    if request.method == 'GET':
        form = LoginForm()
        return render_to_response('login1.html',RequestContext(request,{'form':form,}))
    else:
        form = LoginForm(request.POST)
        if form.is_valid():
            username = request.POST.get('username','')
            password = request.POST.get('password','')



            user = auth.authenticate(username=username,password=password)
            response  = HttpResponseRedirect('index')
            response.set_cookie('username',username,max_age=3600)
#            return response

            if user is not None and user.is_active:
                auth.login(request,user)
                print request.user
                return render_to_response('a.html',RequestContext(request))
            else:
                return render_to_response('login1.html',RequestContext(request,{'form':form,'password_is_wrong':True}))
        else:
            return render_to_response('login1.html',RequestContext(request,{'form':form,}))

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
def signin(request):    
    message = ''
    if request.method == 'POST': 
        form = LoginForm(request.POST) 
        if form.is_valid():
            login_username = form.cleaned_data['login_username']
            login_password = form.cleaned_data['login_password']
            user = authenticate(username=login_username, password=login_password)
            if user is not None:
                if user.is_active:
                    login(request, user)
                    if user.is_superuser:
                        return HttpResponseRedirect('/server1/')
                    else:
                        return HttpResponseRedirect('/server2/')
                else:
                    message='User is disabled'
            else:
                message="Invalid User"
        else:
            message = 'Please enter your username and password.'
    else:
        form = LoginForm()

    return render(request, 'signin.html', {
        'message': message,
        'login_username': '',
        'form': form,
    })

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
def login(request): 
	if request.method == 'POST':  #check to see if form has been submitted
		form = LoginForm(request.POST)  #capture data
		if form.is_valid():  #validate data
			cleaned_data = form.clean()
			username = cleaned_data['username']
   			password = cleaned_data['password']
			if username and password:
				try: #attempt to use email to login
					currentuser = User.objects.get(email = username)
					user = auth.authenticate(username = currentuser.username, password = password)
					auth.login(request, user)
					return HttpResponseRedirect('/')
					
				except: #assume that an actual username has been entered
					user = auth.authenticate(username=username, password=password)
					if user is not None and user.is_active:
						# Correct password, and the user is marked "active"
						auth.login(request, user)
						# Render home page.
						return HttpResponseRedirect('/')
					
				form = LoginForm()
				return render(request, 'login.html', {'form': form, 'form_error':True})
				
    		else:
        		# Return to login page.
				form = LoginForm()
				return render(request, 'login.html', {'form': form, 'form_error':True})
	else:
		form = LoginForm() #load blank form
	return render(request, 'login.html', {'form': form, 'form_error':False})

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
def login(request):
	# user is already logged in
	if request.user.is_authenticated():
		return HttpResponseRedirect('/')
		
	# get the referral
	referral = TheBlameGame.service.getSecureReferral(request)
	
	# handle form
	if request.method == 'POST':
		login_form = LoginForm(request.POST)
		if login_form.is_valid():
			if service.login(
				request,
				login_form.cleaned_data['username'],
				login_form.cleaned_data['password']
			):
				messages.success(request, 'You have been logged in')
				return HttpResponseRedirect(referral)
			else:
				messages.error(request, 'Username and password did not match')
	else:
		login_form = LoginForm()
		
	data = {
		'forms': {
			'login': login_form
		},
	}
	
	return render_to_response('accounts/login.html', data, context_instance = RequestContext(request))

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
	def post(self, request):
		form = LoginForm(None, request.POST or None)
		if form.is_valid():
			login_user(request, form.get_user())
			return redirect('index', permanent=True)
		else:
			return render(request, self.template_name, {'login_form': form})

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
    def post(self, request):
        """
        Gestiona el login de un usuario
        :param request: objeto request
        :return: objeto response
        """
        error_messages = []

        login_form = LoginForm(request.POST)

        if login_form.is_valid():

            username = login_form.cleaned_data.get('user_username')
            password = login_form.cleaned_data.get('user_password')
            user = authenticate(username=username, password=password)
            if user is None:
                error_messages.append('Nombre de usuario o contraseña incorrectos')
            else:
                if user.is_active:
                    login(request, user) # crea la sesión de usuario
                    next_url = request.GET.get('next', '/')
                    return redirect(next_url)
                else:
                    error_messages.append('El usuario no está activo')

        context = {
            'form' : login_form,
            'errors' : error_messages
        }

        return render(request, 'photos/login.html', context)

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
def login(request):
    c = {}
    c.update(csrf(request)) #уточнить нужно ли
    form = LoginForm(request.POST or None)

    if request.user.username:
        return redirect('/')

    c['form_post'] = form

    if form.is_valid():
        print 'я валиден'
        username = form.cleaned_data['username']
        password = form.cleaned_data['password']
        # email = form.cleaned_data['email']
        user = User.objects.all()

        authed = auth.authenticate(username=username, password=password)
        if authed is not None:
            auth.login(request, authed)
            from core import views
            succes_url = reverse(core.views.index)
            return redirect(succes_url) #TODO добавить редирект
        else:
            if not user.filter(username__iexact=username):
                c['login_error'] = "Пользователь не найден"
            # elif not user.filter(email=email):
            #     c['login_error'] = 'Неправильная почта'
            else:
                c['login_error'] = 'Неправильный пароль'
            return render(request, 'auth2/login.html', c)
    else:
        return render(request, 'auth2/login.html', c)

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
def login_view(request):
	mensaje = ""
	#Si el usuario se ha autenticado
	if request.user.is_authenticated():
		return HttpResponseRedirect('/')
	else:
		#Si la solicitud fue enviada...
		if request.method == "POST":
			form = LoginForm(request.POST)
			#Verificar si el formulario cumple con las condiciones de validacion
			if form.is_valid():
				#Limpia los datos ingresados de nombre de usuario y contrasena
				username = form.cleaned_data['username']
				password = form.cleaned_data['password']
				#Procede a autenticar el usuario
				usuario = authenticate(username=username,password=password)
				#Verificar si el usuario existe y si esta activo
				if usuario is not None and usuario.is_active:
					#Enviar la peticion web con el usuario autenticado
					login(request, usuario)
					return HttpResponseRedirect('/')
				#Si no se autentica el usuario
				else:
					#Mostrar un mensaje indicando los fallos
					mensaje = "Usuario y/o password incorrecto"
		form = LoginForm()
		#Envio final del formulario con datos
		ctx = {'form':form, 'mensaje':mensaje}
		#Redirecciona a la pagina del login
		return render_to_response('login.html', ctx, context_instance=RequestContext(request))

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
def index(request):
    request.session['usuario'] = ''
    if request.POST:
        form = LoginForm(request.POST)
        if form.is_valid():
            try:
                m = Usuarios.objects.get(nombre__exact=request.POST['nombre'])
                if m.password == request.POST['password']:
                    request.session['usuario'] = m.nombre
                    if m.rol == 'Cliente':
                        return HttpResponseRedirect('/ingenia/estado_pedido/')
                    else:
                        return HttpResponseRedirect('/ingenia/administrar/')
                    
                else:
                    return HttpResponseRedirect('/ingenia/')
            except Usuarios.DoesNotExist:
                return HttpResponseRedirect('/ingenia/')
        else:
            form = LoginForm()
            args = {}
            args.update(csrf(request))
            args['form'] = form
            return render(request,'pedidos/index.html',args)

    else:
        form = LoginForm()
        args = {}
        args.update(csrf(request))
        args['form'] = form
        return render(request,'pedidos/index.html',args)    

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
def userLogin(request):
    messages =[]
    if request.method == 'POST':
            loginForm = LoginForm(request.POST)
            if loginForm.is_valid():
                user = authenticate(username = loginForm.cleaned_data['username'],\
                                    password = loginForm.cleaned_data['password'])
                
                if user is not None:
                    if user.is_active:
                        login(request, user)
                        messages.append('login successful')
                        return render(request, 'homeLoggedIn.html', {'messages':messages})
                    else:
                        messages.append('login failed: user is not active')
                        loginForm = LoginForm()
                        return render(request, 'signup.html', {'loginForm':loginForm,'messages':messages})
                        # Return a 'disabled account' error message
                        
                else:
                    messages.append("Bad user name and password combination")
                    loginForm = LoginForm()
                    return render(request, 'login.html', {'loginForm':loginForm,'messages':messages})
            else:
                messages.append('Invalid form')
                loginForm = LoginForm()
                return render(request, 'login.html',{'loginForm': loginForm,'messages':messages})
    else:
        loginForm = LoginForm()
        return render(request, 'login.html',{'loginForm': loginForm})

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
    def post(self,request):

        error_messages = []

        login_form = LoginForm(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 None:
                error_messages.append("Nombre de usuario o contrasena incorrectos")
            else:
                if user.is_active:
                    login(request,user) #crea sesion usuario
                    next_url = request.GET.get('next','/')
                    return redirect(next_url)
                else:
                     error_messages.append("El usuario no esta activo")


        context = {
            'form': login_form,
            'errors': error_messages

        }

        return render(request,'photos/login.html',context)

# 需要导入模块: from forms import LoginForm [as 别名]
# 或者: from forms.LoginForm import is_valid [as 别名]
def api_auth(request, output_format='json'):
    """Like auth() but through AJAX"""

    data = {} # Response data 
    status = 200 # Ok

    try:
        if request.is_ajax():
            if request.method == 'POST':
                form = LoginForm(request.POST)

                if form.is_valid():
                    username = form.cleaned_data['username']
                    password = form.cleaned_data['password']

                    # Try to authenticate the user
                    user = authenticate(username=username, password=password)

                    if user is not None:
                        if user.is_active:
                            login(request, user)

                            # Success!
                            data['username'] = username
                        else:
                            raise UserAccountDisabled
                    else:
                        raise BadUsernameOrPassword

                else:
                    # Form didn't validate

                    # HACK ALERT: Incorrect usernames/passwords are 
                    # are checked in the validation code of user.forms.LoginForm
                    # We'll detect this and try to return a more reasonable 
                    # error message.
                    if '__all__' in form.errors.keys():
                        if form.errors['__all__'] == \
                            [form.WRONG_USERNAME_OR_PASSWORD_MSG]:
                            raise BadUsernameOrPassword( \
                                form.WRONG_USERNAME_OR_PASSWORD_MSG) 
        
                    status = 400 # Bad Request
                    data['error'] = "Some required fields are missing"
                    data['field_errors'] = form.errors
                    data['error_html'] = core.utils.build_readable_errors(form.errors)

            else:
                # Method not POST
                raise MethodUnsupported("This endpoint only accepts POSTs.")
        else:
            # Non-AJAX request.  Disallow for now.
            raise NonAjaxRequest( \
                "Remote API calls aren't allowed right now. " + \
                "This might change some day.")

    except NonAjaxRequest, e:
        logger.warning("Non-AJAX API call to %s" % (request.path))
        status = 403 # Forbidden
        data['error'] = "%s" % e