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))
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))
def test_login_form(self):
f = LoginForm(self.user)
self.assertTrue(f.is_valid(), "username and password are validate")
self.user["username"] = "******"
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')
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,
})
def signin(request):
try:
next = request.POST['next']
except KeyError:
try:
next = request.GET['next']
except KeyError:
next = SNAP_PREFIX
if request.POST:
form_data = request.POST.copy()
form = LoginForm(form_data)
if form.is_valid():
user = form.user
login(request, user)
form = LoginForm()
return redirect_to(request, next)
else:
form = LoginForm()
return render_to_response('snapboard/signin.html',
{
'login_form': form,
'login_next': next,
},
context_instance=RequestContext(request))
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))
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))
def account_login(request):
form = LoginForm(request.POST or None)
redirect_to = request.REQUEST.get('next', '')
if request.method == "GET":
if redirect_to and request.user.is_authenticated():
return HttpResponseRedirect(redirect_to)
if request.method == 'POST':
if form.is_valid():
if not redirect_to:
redirect_to = settings.LOGIN_REDIRECT_URL
data = form.cleaned_data
user = authenticate(
username=data['username'],
password=data['password'])
if user:
login(request, user)
if data['remember_me']:
remember_user(request, user)
return HttpResponseRedirect(redirect_to)
else:
form.add_non_field_error(
_("Sorry, you have entered wrong E-mail or Password"))
return render_to_response('account_login.html',
RequestContext(request, {
'form': form,
'next': redirect_to,
}))
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,}))
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})
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})
def login(request):
'''登录动作'''
# 已经是登录状态的用户
if request.session.get('isLogin',False) == True:
return HttpResponseRedirect('/')
s = dir(request.session)
# 非登录状态的用户
loginform = LoginForm(auto_id=True)
if request.method == 'POST':
loginform = LoginForm(request.POST)
if loginform.is_valid():
account = loginform.cleaned_data['account']
password = loginform.cleaned_data['password']
print('account:%s,password:%s'%(account,password))
# TODO:查询数据库内信息,是否登录成功
if account == 'aaaaaa' and password == 'aaaaaa':
request.session['isLogin'] = True
return HttpResponseRedirect('/')
# 表格字段格式错误,或者登录失败
return render_to_response(
'customer/login.html',
{
'form' : loginform,
# TODO: debug用
'session' : request.session.items(),
},
context_instance=RequestContext(request)
)
def login(request):
"""
Log in view
"""
try:
if request.session['email']:
return HttpResponseRedirect('/fb/sucess/')
except:
pass
if request.method == 'POST':
#print request.POST
form = LoginForm(request.POST)
if form.is_valid():
try:
user = Join.objects.filter(email=form.cleaned_data['email'], passwrd=form.cleaned_data['passwrd'])
if len(user) == 1:
request.session['email'] = user[0].email
return HttpResponseRedirect('/fb/sucess/')
else:
return HttpResponse("Login Credentials didn't match, Please try again")
except User.DoesNotExist:
return None
else:
form = LoginForm()
return render(request, 'fb/login.html', {'form': form})
def login_validation(request):
print "=========================="
next = ""
login_msg = {}
login_form = LoginForm(request.POST)
if 'next' in request.GET:
next = request.GET['next']
if login_form.is_valid():
email = request.POST['email_login']
password = request.POST['password_login']
user_auth = authenticate(username=email, password=password)
if user_auth is not None and user_auth.is_active:
login(request, user_auth)
if next != "":
login_msg['redirect_url'] = next
else:
login_msg['redirect_url'] = '/{}'.format(
request.user.school.short_name)
else:
login_msg['error'] = "email and password is wrong"
else:
login_msg['error'] = "something went wrong!"
jsonCtx = json.dumps(login_msg)
return HttpResponse(jsonCtx, mimetype='application/json')
def user_login(request):
if not request.user.is_anonymous():
return HttpResponseRedirect('/')
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
username = cd['username']
password = cd['password']
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
if "next" in request.REQUEST:
return HttpResponseRedirect(request.REQUEST["next"])
else:
return HttpResponseRedirect("/")
else:
form.errors['password'] = u"帐号验证失败！"
context = RequestContext(request, {
'form': form })
return render_to_response("login.html", context)
else:
context = RequestContext(request, {
'form': form })
return render_to_response("login.html", context)
else:
form = LoginForm()
context = RequestContext(request, {
'form': form })
return render_to_response("login.html", context)
def login(request):
if 'openid' in request.GET or request.method == 'POST':
form = LoginForm(request.REQUEST)
if form.is_valid():
client = _openid_consumer(request)
try:
auth_request = client.begin(form.cleaned_data['openid'])
if QUERY_EMAIL:
sreg = SRegRequest()
sreg.requestField(field_name=SRegField.EMAIL, required=True)
auth_request.addExtension(sreg)
ax = FetchRequest()
ax.add(AttrInfo(AXAttribute.CONTACT_EMAIL,
required=True))
auth_request.addExtension(ax)
callback_url = reverse(callback)
state = SocialLogin.marshall_state(request)
callback_url = callback_url + '?' + urlencode(dict(state=state))
redirect_url = auth_request.redirectURL(
request.build_absolute_uri('/'),
request.build_absolute_uri(callback_url))
return HttpResponseRedirect(redirect_url)
except DiscoveryFailure, e:
if request.method == 'POST':
form._errors["openid"] = form.error_class([e])
else:
return render_authentication_error(request)
def v1_login_json(request):
request.session.clear()
success = False
message = ""
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data["username"]
password = form.cleaned_data["password"]
authToken = getAuthToken(request, username, password)
if authToken != None:
# Prewarm the cache with location fixtures
cache.set('contacts-contact1:location', '{"name": "Unknown", "latitude": 35.668879, "longitude": 139.651436}', 3600)
cache.set('contacts-contact2:location', '{"name": "Unknown", "latitude": 35.667979, "longitude": 139.64999}', 3600)
cache.set('contacts-contact3:location', '{"name": "Unknown", "latitude": 35.668885, "longitude": 139.650634}', 3600)
cache.set('contacts-contact4:location', '{"name": "Unknown", "latitude": 35.668737, "longitude": 139.623203}', 3600)
request.session["authToken"] = authToken
request.session["username"] = username
request.session["password"] = password
success = True
message = "You're logged in."
else:
message = "Wrong username or password."
return {"success": success, "message": message}
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 index(request):
def errorHandle(error):
form = LoginForm()
return render_to_response('login/index.html', {'error':error, 'form':form,}, context_instance=RequestContext(request) )
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
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 render_to_response('login/success.html', {'username': username, 'login':user.is_active}, context_instance=RequestContext(request))
else:
error = 'Account disabled'
return errorHandle(error)
else:
error = 'invalid login'
return errorHandle(error)
else:
error = 'Form invalid'
return errorHandle(error)
else:
form = LoginForm()
return render_to_response('login/index.html', {'form':form,}, context_instance=RequestContext(request))
def login(request):
'''登录动作'''
# 已经是登录状态的用户
if request.session.get('isLogin',False) == True:
return HttpResponseRedirect('/')
# 非登录状态的用户
loginform = LoginForm(auto_id=True)
if request.method == 'POST':
loginform = LoginForm(request.POST)
if loginform.is_valid():
account = loginform.cleaned_data['account']
password = loginform.cleaned_data['password']
# 查询数据库内信息,是否登录成功
customer = CustomerModel.objects.filter(account=account, password=password)
if customer :
request.session['isLogin'] = True
request.session['uid'] = customer[0].id
request.session['nickname'] = customer[0].name
return HttpResponseRedirect('/')
# 表格字段格式错误,或者登录失败
return render_to_response(
'customer/login.html',
{
'form' : loginform,
'session' : request.session,
},
context_instance=RequestContext(request)
)
def login(request, template="accounts/account_login.html"):
"""
Login form.
"""
form = LoginForm(request.POST or None)
msg = ""
if request.method == "POST" and form.is_valid():
try:
authenticated_user = form.save()
if authenticated_user is not None:
if authenticated_user.is_active:
auth_login(request, authenticated_user)
# Redirect to a success page.
# TODO redirect to core.dashboard page
p = get_object_or_404(UserProfile, user_id=request.user.pk)
print p
print p.company
request.session["company"] = p.company
return redirect("enterprise.projects")
except forms.ValidationError as e:
print e
print e.message
msg = e
context = {"form": form, "title": _("Log in"), "msg": msg}
return render(request, template, context)
def login(request):
"""
Logs a user in using Django's contrib.auth, and sets the cookie that
the cardstories client expects.
"""
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
# At this point, the user has already been authenticated by form
# validation (which simplifies user feedback on login errors).
auth_login(request, form.auth_user)
GravatarAvatar(form.auth_user).update()
# Redirect maintaining game_id, if set.
url = '%s%s' % (reverse(welcome), get_gameid_query(request))
return redirect(url);
else:
form = LoginForm()
context = {'registration_form': RegistrationForm(),
'login_form': form}
return render_to_response('cardstories/welcome.html', context,
context_instance=RequestContext(request,
processors=[common_variables]))
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)
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)
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
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)
def login(request, template_name='django_yubico/login.html',
redirect_field_name=REDIRECT_FIELD_NAME):
"""
Displays the login form and handles the login action.
"""
redirect_to = request.REQUEST.get(redirect_field_name,
settings.LOGIN_REDIRECT_URL)
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
user = form.user
if YUBIKEY_USE_PASSWORD:
# Dual factor authentication is enabled, user still needs to
# enter his password
request.session[YUBIKEY_SESSION_USER_ID] = user.pk
request.session[YUBIKEY_SESSION_AUTH_BACKEND] = user.backend
request.session[YUBIKEY_SESSION_ATTEMPT_COUNTER] = 1
return HttpResponseRedirect(reverse('yubico_django_password'))
else:
auth_login(request=request, user=user)
return HttpResponseRedirect(redirect_to)
else:
form = LoginForm()
dictionary = {'form': form, redirect_field_name: redirect_to}
return render_to_response(template_name, dictionary,
context_instance=RequestContext(request))
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)
def login(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
email = form.cleaned_data['email']
remember_me = form.cleaned_data['remember_me']
response = HttpResponseRedirect('/management')
# delete autologin object and corresponding cookie of last user if exist -- safe
forget_user(response=response, request=request)
# after custom validation user is known to exist, and no need for password
# since we check it in validator
user = User.objects.get(email=email)
ufps = user.user_forgetpassword_set.all()
if ufps:
ufps.delete()
if remember_me:
response = remember_user(user=user, response=response)
# logged in user
login_user(session=request.session, user=user)
# check if the user came from somewhere and render
return response
# request.method is GET
else:
# An unbound form
form = LoginForm()
return render_form('login_form.html', form, '', request)
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})
def user_login(request):
message = ""
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
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 redirect('/home')
else:
message = "無效的帳號或密碼!"
else:
form = LoginForm()
return render_to_response('login.html', {
'message': message,
'form': form
},
context_instance=RequestContext(request))
def userlogin(request):
if request.method == "POST":
print "post"
return
form = LoginForm(request=request,data=request.POST)
captcha = form['captcha']
if form.is_valid():
return HttpResponseRedirect('/')
else:
return render_to_response('accounts/login.html',{
'captcha':captcha,
"form":form},context_instance = RequestContext(request))
else:
print "else post"
return
form = LoginForm()
captcha = form['captcha']
if request.user.is_authenticated():
return HttpResponseRedirect('/')
return render_to_response('accounts/login.html',{
'captcha':captcha},context_instance = RequestContext(request))
def post(self, request):
login_form = LoginForm(request.POST)
if login_form.is_valid():
user_name = request.POST.get("username", "")
pass_word = request.POST.get("password", "")
user = authenticate(username=user_name, password=pass_word)
if user is not None:
if user.is_active:
login(request, user)
return HttpResponseRedirect(reverse("index"))
else:
return render(request, 'login.html', {
"msg": "用户未激活",
})
else:
return render(request, "index.html", {
"msg": "用户名或者密码错误",
})
else:
return render(request, 'login.html', {
"login_form": login_form,
})
def login_user(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password'])
if user is not None:
if user.is_active:
login(request, user)
return HttpResponseRedirect("/dashboard")
return render_to_response('public/login.html', {
'form': form,
'error': True
},
context_instance=RequestContext(request))
else:
form = LoginForm()
return render_to_response('public/login.html', {'form': form},
context_instance=RequestContext(request))
def login(request):
#should check the authenticaiton status first,if already login, redirect to home page.
#if the form submit, check the validity of form data, if valid, use the username and password to perform
# authentication. if the user is not valid or not been activated, then display the respective message.
#if the user is valid, then login and display the success message.
#if current access is the first time show page, then display the login form.
template = get_template('login.html')
username = None
if request.user.is_authenticated():
messages.add_message(request, messages.INFO,
'Welcome %s' % request.user.username)
username = request.user.username
else:
if request.method == 'GET':
loginform = LoginForm()
else:
loginform = LoginForm(request.POST)
if loginform.is_valid():
username = auth.authenticate(request,\
username = loginform.cleaned_data['username'],\
password = loginform.cleaned_data['password'],\
)
if username and username.is_active:
messages.add_message(request, messages.INFO,
'Welcome %s !' % username)
auth.login(request, username)
else:
username = None
messages.add_message(
request, messages.WARNING,
'Please check your login id/password')
else:
username = None
messages.add_message(request, messages.WARNING,
'Please check your login id/password')
html = template.render(locals(), request)
return HttpResponse(html)
def loginview(request, target):
if request.method == 'POST':
form = LoginForm(request.POST)
if not form.is_valid(): # All validation rules pass
form = LoginForm()
context = {'form': form, 'error': 'Invalid form'}
return scirius_render(request, 'accounts/login.html', context)
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
if not form.cleaned_data['persistent']:
request.session.set_expiry(0)
logger = logging.getLogger('authentication')
logger.info("Successful login for '%s' from '%s'", username,
get_real_ip(request))
return redirect("/" + target)
else:
form = LoginForm()
context = {'form': form, 'error': 'Disabled account'}
logger = logging.getLogger('authentication')
logger.error(
"Invalid login attempt for disabled account '%s' from '%s'",
username, get_real_ip(request))
return scirius_render(request, 'accounts/login.html', context)
else:
form = LoginForm()
context = {'form': form, 'error': 'Invalid login'}
logger = logging.getLogger('authentication')
logger.error("Invalid login attempt for '%s' from '%s'", username,
get_real_ip(request))
return scirius_render(request, 'accounts/login.html', context)
else:
form = LoginForm()
context = {'form': form}
return scirius_render(request, 'accounts/login.html', context)
def login_view(request):
date = datetime.now()
# password = make_password('@rocket')
# user = SignUpModel(username='******', email='*****@*****.**', password=password)
# user.save()
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = SignUpModel.objects.filter(username=username).first()
if user:
# check for the password
if check_password(password, user.password):
token = SessionModel(user=user)
token.create_token()
token.save()
response = redirect('/room/')
response.set_cookie(key='session_token',
value=token.session_token)
return response
else:
print("Incorrect Username or Password")
ctypes.windll.user32.MessageBoxW(
0, u"Incorrect Username or Password", u"Error", 0)
return render(request, 'index.html', {'invalid': True})
else:
print("User does not exist")
ctypes.windll.user32.MessageBoxW(
0, u"User does not exist.Please sign up", u"Error", 0)
return render(request, 'index.html', {'invalid': True})
else:
print("Error: Invalid form")
ctypes.windll.user32.MessageBoxW(
0, u"Invalid form entries.Enter again", u"Error", 0)
else:
form = LoginForm()
return render(request, 'index.html', {'form': form}, {'Date': date})
def login(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
user = authenticate(username=cd['username'],
password=cd['password'])
if user:
auth_login(request, user)
return HttpResponseRedirect(reverse('profile'))
else:
form.errors['__all__'] = form.error_class(
['Username or password incorrect'])
else:
form = LoginForm()
return render(request, 'login_form.html', {
'form': form,
})
def login_view(request):
response_data = {}
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = UserModel.objects.filter(username=username).first()
if user:
if check_password(password, user.password):
token = SessionToken(user=user)
token.create_token()
token.save()
response = redirect('feed/')
response.set_cookie(key='session_token',
value=token.session_token)
return response
else:
response_data['message'] = 'Incorrect Password ! try again'
elif request.method == "GET":
form = LoginForm()
response_data['form'] = form
return render(request, 'login.html', response_data)
def post(self, request):
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')
# buscamos el usuario con ese username y password
user = authenticate(username=username, password=password)
if user is None: # si es null
error_messages.append(
"Nombre de usuario o contraseña incorrectos")
else:
if user.is_active: # si esta activo hacemos el login
login(request, user)
next_url = request.GET.get('next', '/')
return redirect(next_url) # le enviamos al home
else:
error_messages.append("El usuario no está activo")
context = {'form': login_form, 'errors': error_messages}
return render(request, 'photos/login.html', context)
def cms_login(request): #后台管理登录
if request.method == 'GET':
return render(request, 'cms_login.html')
else:
form = LoginForm(request.POST)
if form.is_valid(): #验证表单
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user = authenticate(username=username, password=password) #验证用户
if user:
login(request, user)
nexturl = request.GET.get(
'next') #如果用户没有登录，从其他页面进去，需要进行登录，当登录成功后，在跳转回去，增加用户体验
#print nexturl
if nexturl:
return redirect(nexturl)
else: #当用户是从登录界面进来的，登录成功后，直接进入首页。
return redirect(reverse('cms_index'))
else:
return render(request, 'cms_login.html',
{'errors': u'用户名或密码错误'})
else:
return HttpResponse(u'用户名不规范')
def login_view(request):
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user = UserModel.objects.filter(username=username).first()
if user:
if check_password(password, user.password):
token = SessionToken(user=user)
token.create_token()
token.save()
response = redirect('feed/')
response.set_cookie(key='session_token', value=token.session_token)
return response
else:
form = 'Incorrect Password! Please try again!'
else:
form = 'Fill all the fields!'
elif request.method == 'GET':
form = LoginForm()
return render(request, 'login.html', {'message': form})
def login(request):
next_url = request.GET.get("next", None)
if next_url:
redirect_url = next_url
else:
redirect_url = reverse("account.views.home")
if request.user.is_authenticated():
return redirect(redirect_url)
if request.method == "POST":
form = LoginForm(data=request.POST)
if form.is_valid():
djangologin(request, form.get_user())
return redirect(redirect_url)
else:
form = LoginForm()
breadcrumb = [{"name": u"首页", "url": "/"}, {'name': u'登录'}]
return render_template("login.html",
request,
form=form,
breadcrumb=breadcrumb)
def login_view(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
usr = form.cleaned_data
user = authenticate(username=usr['user'], password=usr['password'])
if user is not None:
if user.is_active:
login(request, user)
return render_to_response(
'home.html', {},
context_instance=RequestContext(request))
# Redirect to a success page.
else:
raise Http404("Your account has been disabled!")
else:
raise Http404("Your username and password were incorrect.")
else:
form = LoginForm()
return render_to_response('login.html', {'form': form},
context_instance=RequestContext(request))
def login_view(request):
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user = User.objects.filter(username=username).first()
if user:
if check_password(password, user.password):
token = SessionToken(user=user)
token.create_token()
token.save()
response = redirect('/post/')
response.set_cookie(key='session_token',
value=token.session_token)
return response
else:
print 'User is invalid'
elif request.method == "GET":
form = LoginForm()
return render(request, 'login.html', {'form': form})
def mlogin(request):
from django.contrib.auth import authenticate, login
from django.contrib.auth.models import User
from forms import LoginForm
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
name_or_email = form.cleaned_data["name_or_email"]
password = form.cleaned_data["password"]
remember_me = form.cleaned_data["remember_me"]
user = authenticate(username=name_or_email, password=password)
if user is not None:
if user.is_active:
login(request, user)
return HttpResponseRedirect("/")
else:
return render_to_response(
"form.html", {
"aform": form,
"err_message": "Disabled Account!",
})
else:
return render_to_response(
"form.html", {
"aform": form,
"err_message": "Username or Password were incorrect!",
})
else:
return render_to_response(
"form.html", {
"aform": form,
"err_message": "Information is not complete!",
})
else:
return render_to_response("form.html", {"aform": LoginForm()})
def login_view(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
# authenticate
email = form.cleaned_data['email_address']
password = form.cleaned_data['password']
user = authenticate(username=email, password=password)
if user is not None:
# authenticated
# log in the user
login(request, user)
next_url = request.POST.get('next', None)
if next_url:
print 'Got Next parameter'
return HttpResponseRedirect(next_url)
return render(request, 'index.html', {'user': user})
else:
# not authenticated
error = {'msg': 'Could not validate credentials'}
return render(request, 'login.html', {
'form': form,
'error': error
})
else:
user = request.user
if user and user.is_authenticated():
return HttpResponseRedirect('/')
form = LoginForm()
return render(request, 'login.html', {'form': form})
def login(request):
errors = []
if request.method == 'POST':
#pdb.set_trace()
form = LoginForm(data=request.POST)
if form.is_valid():
success = _login(request, form.cleaned_data["username"],
form.cleaned_data["password"])
if success:
if request.POST['next']:
return HttpResponseRedirect(request.POST['next'])
else:
return HttpResponseRedirect('/')
else:
errors += [_("Sorry, that's not a valid username or password")]
else:
form = LoginForm()
return render_to_response("accounts/login.html", {
'form': form,
'errors': errors
},
context_instance=RequestContext(request))
def login_view(request):
response_data = {}
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user = UserModel.objects.filter(username=username).first()
if user:
if check_password(password, user.password):
token = SessionToken(user=user)
token.create_token()
token.save()
response = redirect('feed/')
response.set_cookie(key='session_token',
value=token.session_token)
return response
else:
ctypes.windll.user32.MessageBoxW(0,
u"Invalid Credentials!",
u"Error", 0)
response_data['message'] = 'Please try again!'
else:
ctypes.windll.user32.MessageBoxW(0, u"Invalid Credentials!",
u"Error", 0)
elif request.method == 'GET':
form = LoginForm()
response_data['form'] = form
return render(request, 'login.html', response_data)
def login_view(request, next_page=None):
tpl_vars = {'header': 'page', 'logged': False, 'signupform': SignupForm()}
if request.method == 'POST':
loginform = LoginForm(request.POST)
tpl_vars['loginform'] = loginform
if loginform.is_valid():
cd = loginform.cleaned_data
username, password = cd['username'], cd['password']
user = UserProfile.find(username)
if user:
if user.check_password(password):
user.backend = 'mongoengine.django.auth.MongoEngineBackend'
login(request, user)
if next_page:
return redirect(next_page)
return redirect('/')
loginform.errors['username'] = ['invalid username/password']
return render_to_response('twtapp/login.html',
RequestContext(request, tpl_vars))
# Invalid form data
return render_to_response('twtapp/login.html',
RequestContext(request, tpl_vars))
# We don't have a POST(so, it's most probably, a GET!)
if request.GET.get('next', None):
tpl_vars['hidden_next'] = request.GET['next']
tpl_vars['loginform'] = LoginForm()
return render_to_response('twtapp/login.html',
RequestContext(request, tpl_vars))
def do_login(request):
try:
if request.method == 'POST':
login_form = LoginForm(request.POST)
if login_form.is_valid():
# 登录
username = login_form.cleaned_data["username"]
password = login_form.cleaned_data["password"]
user = authenticate(username=username, password=password)
if user is not None:
user.backend = 'django.contrib.auth.backends.ModelBackend' # 指定默认的登录验证方式
login(request, user)
else:
return render(request, 'failure.html',
{'reason': '登录验证失败'})
return redirect(request.POST.get('source_url'))
else:
return render(request, 'failure.html',
{'reason': login_form.errors})
else:
login_form = LoginForm()
except Exception as e:
logger.error(e)
return render(request, 'login.html', locals())
def post(self, request):
errors_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:
errors_messages.append(
'Nombre de usuario o contraseña incorrecto')
else:
if user.is_active:
# crea la sesion de usuario
login(request, user)
next_url = request.GET.get('next', '/')
return redirect(next_url)
else:
errors_messages.append('El usuario no esta activo')
context = {'form': login_form, 'errors': errors_messages}
return render(request, 'photos/login.html', context)
def login(request):
error = ''
if request.method == 'POST':
if 'logout' in request.POST:
logout(request)
return HttpResponseRedirect('/')
login_form = None
if request.method == 'POST':
login_form = LoginForm(request.POST)
if login_form.is_valid():
login_form.login(request)
else:
login_form = LoginForm()
t = loader.get_template('login.view')
c = {
'is_authenticated': request.user.is_authenticated(),
'login_form': login_form
}
c.update(csrf(request))
return HttpResponse(t.render(Context(c)))
def user_login(request):
if request.method == "POST":
if len(request.POST.get('next')) > 0:
_next = request.POST.get('next')
else:
_next = "/"
form = LoginForm(request.POST)
if form.is_valid():
username = request.POST.get('username')
password = request.POST.get('password')
try:
data = myUser.objects.get(username=username)
if data.is_staff and data.is_active and data.availabity == 1:
_user = authenticate(username=username, password=password)
auth_login(request, _user)
userAuth = getAuth(data)
request.session['menuAuth'] = userAuth
return HttpResponseRedirect(_next)
except Exception as e:
import traceback; e= traceback.print_exc();
print e
return render_to_response('accounts/login.html', locals(), context_instance=RequestContext(request))
return render_to_response('accounts/login.html', locals(), context_instance=RequestContext(request))
def user_login(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=form.data['username'],
password=form.data['password'])
if user:
# Is the account active? It could have been disabled.
if user.is_active:
# If the account is valid and active, we can log the user in.
# We'll send the user back to the homepage.
login(request, user)
if user.userprofile.client:
return HttpResponseRedirect(
reverse('index',
args=(user.userprofile.client.username, )))
elif user.is_staff or user.is_superuser or user.userprofile.vendor:
return HttpResponseRedirect('/admin')
else:
raise Http404("That user not found")
else:
# An inactive account was used - no logging in!
return HttpResponse(
"Sorry, this Voiceover Portal account has been disabled."
)
else:
# Bad login details were provided. So we can't log the user in.
print("Invalid login details: {0}, {1}".format(
form.data['username'], form.data['password']))
return HttpResponse("Invalid login details supplied.")
else:
if request.user.is_authenticated():
logout(request)
form = LoginForm()
return render(request, 'login.html', {'form': form})
def login(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/')
# next_page = request.POST.get('next', request.GET.get('next', ''))
if request.method == 'GET':
next = request.GET.get('next', '/')
if next == "/accounts/logout/":
next = '/'
form = LoginForm(request)
return render(request, 'accounts/login.html', locals())
if request.method == 'POST':
form = LoginForm(request, request.POST)
if form.is_valid():
auth.login(request, form.get_user())
return HttpResponseRedirect(request.POST['next'])
else:
return render(request, 'accounts/login.html', locals())
else:
return render(request, 'accounts/login.html', locals())
def login(request):
if request.GET.has_key('openid') or request.method == 'POST':
form = LoginForm(request.REQUEST)
if form.is_valid():
client = _openid_consumer(request)
try:
auth_request = client.begin(form.cleaned_data['openid'])
if QUERY_EMAIL:
sreg = SRegRequest()
sreg.requestField(field_name=SRegField.EMAIL,
required=True)
auth_request.addExtension(sreg)
ax = FetchRequest()
ax.add(AttrInfo(AXAttribute.CONTACT_EMAIL, required=True))
auth_request.addExtension(ax)
redirect_url = auth_request.redirectURL(
request.build_absolute_uri('/'),
request.build_absolute_uri(reverse(callback)))
return HttpResponseRedirect(redirect_url)
except DiscoveryFailure, e:
if request.method == 'POST':
form._errors["openid"] = form.error_class([e])
else:
return render_authentication_error(request)
def login_view(request):
response_data = {}
#check if request is POST
if request.method == "POST":
#define form
form = LoginForm(request.POST)
#check if form is valid
if form.is_valid():
#retrieve username
username = form.cleaned_data.get('username')
#retrieve password
password = form.cleaned_data.get('password')
user = UserModel.objects.filter(username=username).first()
#check if user exixts
if user:
#check if password is correct
if check_password(password, user.password):
print 'Here'
token = SessionToken(user=user)
#creating session token
token.create_token()
#saving session token
token.save()
#redirect to feeds page
response = redirect('feed/')
response.set_cookie(key='session_token',
value=token.session_token)
return response
else:
response_data[
'message'] = "Invalid Password! Please try again!!!"
elif request.method == "GET":
form = LoginForm()
response_data['form'] = form
#load login page
return render(request, 'login.html', response_data)
def userlogin(request):
if request.method == "POST":
form = LoginForm(request=request,data=request.POST)
print "userlogin name=",form['username']
captcha = form['captcha']
print "captcha =",captcha
if form.is_valid():
if not User.objects.all().filter(username__exact="gongpengrong"):
user = User()
user.username = "******"
user.set_password("gongpengrong")
user.save()
return render(request, "index.html", {"form":form})
else:
print "form is not valid"
return render(request, 'accounts/login.html', {'captcha':captcha, "form":form})
else:
form = LoginForm()
if request.user.is_authenticated():
return HttpResponseRedirect('/')
form = LoginForm()
captcha = form['captcha']
return render(request,'accounts/login.html', {"captcha":captcha})
def login_view(request):
# Login form submitted
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
error_msg = ''
try:
user = User.objects.get(username=data['username'])
if user.check_password(data['password']) and user.is_active:
user.backend = 'mongoengine.django.auth.MongoEngineBackend'
login(request, user)
# Put profile in the session
request.session['profile'] = UserProfile.objects.get(
user=user)
return HttpResponseRedirect(reverse('user_landing'))
else:
return _fail_login(
request,
'invalid login (note: you must Sign in with Google if that\'s how you signed up initially)'
)
except User.DoesNotExist:
return _fail_login(
request,
'invalid login (note: you must Sign in with Google if that\'s how you signed up initially)'
)
#form = LoginForm()
return render_to_response('login.html',
locals(),
context_instance=RequestContext(request))
# Login form needs rendering
else:
# if request.user.is_authenticated():
if request.user.is_authenticated():
return redirect(user_show)
import urllib2
from urllib import urlencode
from xml.dom import minidom
from xml.parsers.expat import ExpatError
########################################
def get_endpoint():
'''
Get Google's authentication endpoint.
returns the url as a string
'''
# Get discovery URL
try:
response = urllib2.urlopen(GOOGLE_GET_ENDPOINT_URL)
except urllib2.URLError:
return _fail_login(request, 'could not contact Google')
# Parse XML response
try:
parsed = minidom.parseString(response.read())
except ExpatError as error:
return _fail_login(
request, 'invalid response from Google: {}'.format(
error.strerror()))
URI = parsed.getElementsByTagName('URI')
if len(URI) <= 0 or len(URI[0].childNodes) <= 0:
return _fail_login(
request, 'could not find Google authentication server')
return URI[0].childNodes[0].toxml()
########################################
endpoint = str(get_endpoint())
params = {
'openid.mode': 'checkid_setup',
'openid.ns': 'http://specs.openid.net/auth/2.0',
'openid.claimed_id':
'http://specs.openid.net/auth/2.0/identifier_select',
'openid.identity':
'http://specs.openid.net/auth/2.0/identifier_select',
'openid.return_to': _hostname() + reverse('google_login_success'),
'openid.realm': 'http://llovett.cs.oberlin.edu:8050',
'openid.ns.ax': 'http://openid.net/srv/ax/1.0',
'openid.ax.mode': 'fetch_request',
'openid.ax.type.email': 'http://axschema.org/contact/email',
'openid.ax.type.firstname': 'http://axschema.org/namePerson/first',
'openid.ax.type.lastname': 'http://axschema.org/namePerson/last',
'openid.ax.required': 'email,firstname,lastname'
}
if request.user.is_authenticated():
profile = UserProfile.objects.get(user=request.user)
if profile.openid_auth_stub:
params[
'openid.assoc_handle'] = profile.openid_auth_stub.association
form = LoginForm()
return render_to_response('login.html',
locals(),
context_instance=RequestContext(request))
