def login(request, template_name='accounts/login.html',
extra_context={}):
"""
contrib.auth.views.login, but with a few added benefits: extra_context and
it redirects to settings.LOGIN_REDIRECT_URL if user is already logged in.
"""
if request.method == 'POST':
form = AuthenticationForm(data=request.POST)
if form.is_valid():
redirect_to = get_redirect_url(request, redirect_field_name='next',
fallback=settings.LOGIN_REDIRECT_URL)
auth_raw_login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
return HttpResponseRedirect(redirect_to)
else:
form = AuthenticationForm(request)
request.session.set_test_cookie()
if Site._meta.installed:
current_site = Site.objects.get_current()
else:
current_site = RequestSite(request)
context = {
'form': form,
'site': current_site,
'site_name': current_site.name
}
context.update(extra_context)
return direct_to_template(request, template_name, context)
def login(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME):
"Displays the login form and handles the login action."
redirect_to = request.REQUEST.get(redirect_field_name, '')
if request.method == "POST":
form = AuthenticationForm(data=request.POST)
if form.is_valid():
# Light security check -- make sure redirect_to isn't garbage.
if not redirect_to or '//' in redirect_to or ' ' in redirect_to:
redirect_to = settings.LOGIN_REDIRECT_URL
from django.contrib.auth import login
login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
return HttpResponseRedirect(redirect_to)
else:
form = AuthenticationForm(request)
request.session.set_test_cookie()
if Site._meta.installed:
current_site = Site.objects.get_current()
else:
current_site = RequestSite(request)
return render_to_response(template_name, {
'form': form,
redirect_field_name: redirect_to,
'site_name': current_site.name,
}, context_instance=RequestContext(request))
def login(request, template_name="lfs/checkout/login.html"):
"""Displays a form to login or register/login the user within the check out
process.
The form's post request goes to lfs.customer.views.login where all the logic
happens - see there for more.
"""
# If the user is already authenticate we don't want to show this view at all
if request.user.is_authenticated():
return HttpResponseRedirect(reverse("lfs_checkout"))
shop = lfs.core.utils.get_default_shop(request)
# If only anonymous checkout allowed we don't want to show this view at all.
if shop.checkout_type == CHECKOUT_TYPE_ANON:
return HttpResponseRedirect(reverse("lfs_checkout"))
# Using Djangos default AuthenticationForm
login_form = AuthenticationForm()
login_form.fields["username"].label = _(u"E-Mail")
register_form = RegisterForm()
if request.POST.get("action") == "login":
login_form = AuthenticationForm(data=request.POST)
login_form.fields["username"].label = _(u"E-Mail")
if login_form.is_valid():
from django.contrib.auth import login
login(request, login_form.get_user())
return lfs.core.utils.set_message_cookie(reverse("lfs_checkout"),
msg=_(u"You have been logged in."))
elif request.POST.get("action") == "register":
register_form = RegisterForm(data=request.POST)
if register_form.is_valid():
email = register_form.data.get("email")
password = register_form.data.get("password_1")
# Create user
user = User.objects.create_user(
username=create_unique_username(email), email=email, password=password)
# Notify
lfs.core.signals.customer_added.send(user)
# Log in user
from django.contrib.auth import authenticate
user = authenticate(username=email, password=password)
from django.contrib.auth import login
login(request, user)
return lfs.core.utils.set_message_cookie(reverse("lfs_checkout"),
msg=_(u"You have been registered and logged in."))
return render_to_response(template_name, RequestContext(request, {
"login_form": login_form,
"register_form": register_form,
"anonymous_checkout": shop.checkout_type != CHECKOUT_TYPE_AUTH,
}))
def login(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME):
if TEMP_DEBUG_LOGGING:
TEMP_DEBUG_FILE = open('/tmp/os-debug.log','a')
TEMP_DEBUG_FILE.write("\nLogin:"******"\n")
"Displays the login form and handles the login action."
if request.method == "POST":
form = AuthenticationForm(data=request.POST)
from django.contrib.auth import login
if form.is_valid():
user = form.get_user()
# Check if the user is banned
user_ob = User.objects.filter(username = user)
if len(user_ob) != 0:
if len(BanishedUser.objects.filter(user = user_ob[0])) != 0:
return json_result({'form_errors': {"__all__":["User is banned"]}})
login(request, user)
# If this was a visitor, connect to a user
connect_visitor_to_user(request, user.id)
# Log the login
create_user_event_log(request, {"log_type": LogUserEvents.login})
if TEMP_DEBUG_LOGGING:
TEMP_DEBUG_FILE.write("Login results is user_authenticated?" + str(request.user.is_authenticated()))
TEMP_DEBUG_FILE.close()
return json_result({'success' : True, 'sms_can_change_password': get_sms_can_change_password(request.user)})#json_success()
else:
if Settings.objects.boolean('SOFT_ENTRY_CODES'):
c = request.POST.get('entrycode','')
code_object = EntryCode.objects.filter(code = c)
if len(code_object) <= 0:
return json_error('Invalid Entry Code')
u = User.objects.filter(username = code_object[0].username)
if len(u) <= 0:
return json_error('Entry code and user do not match')
if code_object[0].first_login:
first_login_time = UserData(user = u[0], key = 'first_login', value = time.time())
first_login_time.save()
code_object[0].first_login = False
code_object[0].save()
connect_visitor_to_user(request, u[0].id)
request.session['user_id'] = u[0].id
request.session['_auth_user_id'] = u[0].id
request.session['_auth_user_backend'] = 'opinion.email-auth.EmailOrUsernameModelBackend'
return json_success()
# Invalid login
if TEMP_DEBUG_LOGGING:
TEMP_DEBUG_FILE.write(json_result({'form_errors': errors_to_dict(form.errors)}).content)
TEMP_DEBUG_FILE.close()
return json_result({'form_errors': errors_to_dict(form.errors)})
else:
return json_error('Invalid request.')
def custlogin(request, template_name="custlogin.html"):
context = {}
context.update(csrf(request))
next = None
try:
next = request.GET['next']
except:
next = ""
auth_frm = AuthenticationForm(data=request.POST or None)
context['form'] = auth_frm
if auth_frm.is_valid():
try:
user = authenticate(
username=auth_frm.cleaned_data['username'],
password=auth_frm.cleaned_data['password'])
login(request, user)
except Exception:
pass
#return the same form and say login failed
return HttpResponseRedirect('')
return render(
template_name, context, context_instance=RequestContext(request))
def login(request):
"""Try to login existing user"""
if request.user.is_authenticated():
return redirect('profile')
if request.method == 'POST':
form = AuthenticationForm(data=request.POST)
if not form.is_valid():
return render(
request,
'index.html',
{'error_message': 'Sorry, could not login', 'login': True}
# {'error_message':
# ' '.join([e.as_text() for e in form.errors.values()])}
)
# If form is valid, try to authenticate user
user = authenticate(
username=form.cleaned_data['username'],
password=form.cleaned_data['password']
)
if user is not None:
# Log in and redirect to profile
login_user(request, user)
return redirect('profile')
else:
return render(
request,
'index.html',
{'error_message': 'Sorry, could not login', 'login': True}
)
# Otherwise, display login page
return render(request, 'index.html', {'login': True})
def entrar(request):
user = request.user
ctx = {}
if request.method == 'GET' and 'next' in request.GET: #miramos si está la variables next para redirección
ctx['next'] = request.GET['next'] #guardamos la variables next para enviar al template
#Comprobamos si el usuario está autenticado!
if user.is_authenticated():
return redirect( get_url_redir(request) )
#Si el usuario envía datos por POST para su autenticación
if request.method == 'POST':
form = AuthenticationForm(data=request.POST) #usamos el formulario de auth de django
if form.is_valid(): #si el form es válido obtenemos el usuario y password
u = form.cleaned_data['username']
p = form.cleaned_data['password']
user = authenticate(username=u, password=p) #comprobamos usuario y contraseña
if user is not None and user.is_active: #si existe y si está activo
login(request, user) #logueado en las sesion de django
# dependiendo del depto al q pertenece el user así se redirecionará
return redirect( get_url_redir(request) )
else:
ctx['form'] = form #guardamos el form con los datos resultantes de la validación
return render(request, 'GestionUser/entrar.html', ctx)
form = AuthenticationForm() #un formulario sin datos del POST
ctx['form'] = form #guardamos un form limpio
return render(request, 'GestionUser/entrar.html', ctx)
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 login_view(request):
# TODO: rethink and rewrite
next = request.GET.get('next', '')
if request.method != 'POST':
form = AuthenticationForm(request)
return render_to_response('registration/login.html', {'form': form, 'next': next},
context_instance=RequestContext(request))
else:
form = AuthenticationForm(data=request.POST)
if not form.is_valid():
return render_to_response('registration/login.html', {'form': form, 'next': next},
context_instance=RequestContext(request))
user = authenticate(username=request.POST['username'], password=request.POST['password'])
if user is not None:
if user.is_active:
#Save username in session
PREFIX = "_user:"******"login", game = None, public=False)
if request.POST.get('next'):
return HttpResponseRedirect(request.POST.get('next'))
return redirect(settings.LOGIN_REDIRECT_URL)
return HttpResponseRedirect("/")
def index(request):
if request.method == "POST":
# User authentication
auth_form = AuthenticationForm(data = request.POST)
if auth_form.is_valid():
user = auth_form.get_user()
if user.is_active:
login(request, user)
# Contact form handling
contact_form = AkismetContactForm(request = request, data = request.POST)
if contact_form.is_valid():
contact_form.save()
else:
auth_form = AuthenticationForm()
contact_form = AkismetContactForm(request = request)
return render_to_response('index.html',{
'auth_form': auth_form,
'contact_form': contact_form,
'project_list': Project.objects.all(),
'user_list': User.objects.all().order_by('first_name')
}, context_instance = RequestContext(request))
def authenticate_user(username, password):
# reuse form-model logic in AuthenticationForm
auth_dict = {"username": username, "password": password}
auth_form = AuthenticationForm(None, auth_dict)
is_valid = auth_form.is_valid() # just run the validation
auth_user = auth_form.get_user()
return auth_user
def fg_login(request,template_name="Login.html"):
context = {}
context.update(csrf(request))
next = None
try:
next = request.GET['next']
except:
next = ""
auth_frm = AuthenticationForm(data=request.POST or None)
context['form'] = auth_frm
if auth_frm.is_valid():
try:
user = authenticate(username=auth_frm.cleaned_data['username'], password=auth_frm.cleaned_data['password'])
login(request, user)
except Exception, e:
pass
return redirect('manager_home')
def loginUsuario(request, template_name='user/loginUsuario.html'):
if not request.user.is_anonymous():
return redirect('home')
if request.method == 'POST':
formulario = AuthenticationForm(None, request.POST or None)
if formulario.is_valid():
usuario = request.POST['username']
clave = request.POST['password']
acceso = authenticate(username=usuario, password=clave)
if acceso is not None:
if acceso.is_active:
login(request, acceso)
return redirect('home')
print 'acceso'
else:
print 'no activo'
return redirect('home')
else:
print 'no usuario'
return redirect('home')
else:
formulario = AuthenticationForm()
else:
formulario = AuthenticationForm()
return render(request, template_name, locals())
def login(request):
c = all_page_infos(request)
nexturl = request.GET.get("next", "/")
if request.method == 'POST':
form = AuthenticationForm(data=request.POST)
form.fields["password"].max_length = 4096
if form.is_valid():
user = form.get_user()
django_contrib_auth_login(request, user)
logger.info("Logged in user '%s' (%s) a.k.a '%s'", user.username, user.last_name, user.userprofile.aliases)
if request.user.userprofile.game_pref_fixed or request.session.get("game_pref", 0) == 0:
# if pref was set explicitely, always set cookie according to profile
# or if no cookie set, use profiles setting (even if 0)
request.session["game_pref"] = request.user.userprofile.game_pref
else:
# cookie is already set (!=0), overwrite users pref as it's not fixed
try:
request.user.userprofile.game_pref = int(request.session["game_pref"])
request.user.userprofile.save()
except ValueError:
# not int, ignore
pass
return HttpResponseRedirect(nexturl)
else:
logger.info("login error: %s", form.errors)
else:
form = AuthenticationForm()
c["next"] = nexturl
c['form'] = form
form.fields["password"].max_length = 4096
return render(request, 'login.html', c)
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 test_invalid_username(self):
# The user submits an invalid username.
data = {"username": "******", "password": "******"}
form = AuthenticationForm(None, data)
self.assertFalse(form.is_valid())
self.assertEqual(form.non_field_errors(), [force_unicode(form.error_messages["invalid_login"])])
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 login_or_logout_form(context, next):
"""
Usage: {% login_or_logout_form next %}
After: Depending on whether the browsing user is logged in or not a login or logout
form has been displayed
After a successful login the user is redirected to the url next
"""
user = context['user']
request = context['request']
login_url = reverse('login')
if request.path == login_url:
return {'on_login_page': True }
if next == login_url:
next = reverse('index')
if not user.is_authenticated():
form = AuthenticationForm(auto_id = "login-form-%s")
form.fields['username'].widget.attrs['tabindex'] = 1
form.fields['password'].widget.attrs['tabindex'] = 2
form.id = "login-form"
return {'login' : True, 'form' : form , 'next': next}
else:
return {'login': False }
def wrapper(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME):
if Site._meta.installed:
current_site = Site.objects.get_current()
else:
current_site = RequestSite(request)
if request.method == 'POST':
# sometimes we won't have made a get request yet (i.e. if we use a
# form on a different page to login) so if the referer was
# from our own site skip the cookie check
referer = request.META.get('HTTP_REFERER', None)
try:
referer = referer.split(u'//')[1]
except AttributeError:
referer = ''
cookies = request.session.test_cookie_worked()
form = AuthenticationForm(request, request.POST)
form.is_valid()
else:
cookies = True
form = AuthenticationForm(request.POST)
request.session.set_test_cookie()
if cookies or referer.startswith(current_site.domain):
request.session.delete_test_cookie()
return f(request, template_name, redirect_field_name)
return render_to_response(template_name, {
'form': form,
redirect_field_name: redirect_field_name,
'site_name': current_site.name,
}, context_instance=RequestContext(request))
def login(request):
result = {"status": 0, "apiVersion": "1.0", "msg": "", "data": {}}
form = AuthenticationForm(request, request.POST)
if not form.is_valid():
result['msg'] = u'用户名或者密码错误'
return json_response(result)
user = form.get_user()
if not user.is_active:
result['msg'] = u'该账户未激活,请先使用邮箱链接进行激活'
return json_response(result)
# if not check_user(user):
# result['msg'] = u'该用户不存在'
# return json_response(result)
if is_super_admin(user):
result['data']['next'] = '/superadmin/'
elif is_admin(user):
result['data']['next'] = '/secretary/'
elif is_instructor(user):
result['data']['next'] = '/instructor/'
# return HttpResponseRedirect(reverse('instructor'))
elif is_student(user):
result['data']['next'] = '/student/'
else:
result['msg'] = '该用户不存在'
return json_response(result)
auth_login(request, user)
result['status'] = 1
result['msg'] = u'登录成功'
return json_response(result)
def post(self, request):
form = AuthenticationForm(data=request.POST)
if not form.is_valid():
return self.response(request, form)
user = form.get_user()
auth_login(request, user)
# Retrieve user to use some methods of UserProxy
user = UserProxy.objects.get(pk=user.pk)
if user.is_superuser or user.is_system_user or user.is_audit_user or user.is_safety_user:
return redirect('management')
udc_set = UDC.objects.filter(user=user)
if udc_set.exists():
request.session["UDC_ID"] = udc_set[0].id
elif user.is_approver:
request.session["UDC_ID"] = -1
else:
return redirect('no_udc')
Notification.pull_announcements(user)
return HttpResponseRedirect(reverse("cloud"))
def login(request, species_wid=None):
next = request.REQUEST.get('next', '')
if request.method == "POST":
form = AuthenticationForm(data=request.POST)
if form.is_valid():
auth_login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
return HttpResponseRedirect(next)
else:
form = AuthenticationForm(request)
request.session.set_test_cookie()
return render_queryset_to_response(
species_wid = species_wid,
request = request,
templateFile = 'public/login.html',
data = {
'form': form,
'next': next,
})
def login_usuario(request):
menu=permisos(request)
if request.method=="POST":
form=AuthenticationForm(request.POST)
if(form.is_valid()==False):
username=request.POST["username"]
password=request.POST["password"]
resultado=authenticate(username=username,password=password)
if resultado:
login(request,resultado)
request.session["name"]=username
return HttpResponseRedirect("/blog/active/")
else:
request.session['cont']=request.session['cont']+1
aux=request.session['cont']
estado=True
mensaje="Error en los datos "+str(aux)
if aux>3:
formulario2=fcapcha()
datos={'form':form,'formulario2':formulario2,'estado':estado,'mensaje':mensaje}
else:
datos={'form':form,'estado':estado,'mensaje':mensaje}
return render_to_response("usuario/login.html",datos,context_instance=RequestContext(request))
else:
request.session['cont']=0
form=AuthenticationForm()
return render_to_response("usuario/login.html",{"menu":menu,"form":form},RequestContext(request))
def index(request):
if request.method == 'POST': # If the form has been submitted...
# ContactForm was defined in the the previous section
print request.POST
form = AuthenticationForm(data=request.POST) # A form bound to the POST data
form2 = UserCreateForm(data=request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
# ...
return HttpResponseRedirect('/thanks/') # Redirect after POST
if form2.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
# ...
return HttpResponseRedirect('/thanks/') # Redirect after POST
else:
form = AuthenticationForm() # An unbound form
form2 = UserCreateForm() # An unbound form
return render(request, 'promotion/index.html', {
'form_auth': form,
'form_rec': form2,
})
def login(request, template_name="login.html"):
if request.method == "GET":
authenticationForm = AuthenticationForm()
elif request.method == "POST":
authenticationForm = AuthenticationForm(data=request.POST)
if authenticationForm.is_valid():
user = authenticationForm.get_user()
auth_login(request, user)
if user.is_superuser:
return redirect('management')
ucc = UDC.objects.filter(user=user)
if ucc:
request.session["UDC_ID"] = ucc[0].id
else:
raise Exception("User has not register to any SDDC")
return HttpResponseRedirect(reverse("cloud"))
return render_to_response(template_name, RequestContext(request, {
"authenticationForm": authenticationForm,
"error": authenticationForm.errors.get('__all__', None),
"BRAND": settings.BRAND,
}))
def login(request):
if request.method == 'GET':
redirect_to = request.GET.get('next', '/')
return render(request, 'accounts/login.html', {
'form': AuthenticationForm(),
'next': redirect_to
})
else:
form = AuthenticationForm(request, request.POST)
if form.is_valid():
login(request, form.get_user())
return HttpResponseRedirect(redirect_to)
redirect_to = request.POST.get('next', '/')
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
auth.login(request, user)
return HttpResponseRedirect(redirect_to)
return render(request, 'accounts/login.html', {
'form': form,
'next': redirect_to
})
def home(request):
form = AuthenticationForm()
if request.method == "POST":
form = AuthenticationForm(data=request.POST)
if form.is_valid():
login(request, form.get_user())
return render_to_response('home.html', {'form': form}, context_instance=RequestContext(request))
def login(request):
username = request.REQUEST.get('username')
if username:
userlist = get_user_model().objects.filter(username=username)[:1]
if len(userlist) > 0:
user = userlist[0]
if not user.is_active:
return getResult(False, u'用户已经停止使用。')
form = AuthenticationForm(data=request.POST)
if form.is_valid():
# 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()
org_num = request.user.person_set.filter(is_action=True).count()
if org_num == 1:
request.session['person'] = request.user.paper_set.filter(is_action=True)[0]
request.session['org'] = request.session['person'].org
if not request.user.email_active:
return getResult(True, u'登录成功,请完成邮箱验证', None, 202)
return getResult(True, u'登录成功', None)
else:
return getResult(False, u'用户名密码错误', request.session.session_key, 500)
def login(request):
redirect_to = request.REQUEST.get(REDIRECT_FIELD_NAME, "")
if request.method == "POST":
form = AuthenticationForm(request, data=request.POST)
if form.is_valid():
# Worden we wel naar een veilige pagina gestuurd?
if not is_safe_url(url=redirect_to, host=request.get_host()):
redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL)
user = form.get_user()
auth_login(request, user)
# Primaire organisatie instellen
if hasattr(user, "profile") and user.profile.current_organization:
request.session["organization_pk"] = user.profile.current_organization.pk
if not user.first_name or not user.email:
# User information is not complete, redirect to register page.
return redirect(register)
return redirect(redirect_to)
else:
form = AuthenticationForm(request)
redirect_field_name = REDIRECT_FIELD_NAME
return render(request, "general/login.html", locals())
def login(request):
#messages.debug(request, "Debug!")
#messages.info(request, "Info!")
#messages.success(request, "Success!")
#messages.warning(request, "Warning!")
#messages.error(request, "Error!")
if request.user.is_authenticated():
return redirect("/student")
context = {}
if request.method == "POST":
form = AuthenticationForm(None, request.POST)
if form.is_valid():
user = form.get_user()
print(user)
if user.is_active:
do_login(request, user)
return redirect("/student")
else:
messages.error(request, "Benutzeraccount ist deaktiviert!")
else:
form = AuthenticationForm()
context["form"] = form
return render(request, "session/login.html", context, context_instance=RequestContext(request))
def accounts(request):
return render_to_response("registration/accounts.html", {
"createForm": UserCreationForm(),
"loginForm": AuthenticationForm()
}, RequestContext(request))
def index(request) -> render:
if request.method == 'GET':
form = AuthenticationForm()
return render(request, 'general/index.html', {'form': form})
def log_request(request, login_unsuccessful):
failures = 0
attempt = get_user_attempt(request)
if attempt:
failures = attempt.failures_since_start
# no matter what, we want to lock them out
# if they're past the number of attempts allowed
if failures > FAILURE_LIMIT and LOCK_OUT_AT_FAILURE:
# We log them out in case they actually managed to enter
# the correct password.
logout(request)
log.warning('AXES: locked out %s after repeated login attempts.',
attempt.ip_address)
return False
if login_unsuccessful:
#interpret the auth form to get the user in question
if request.method == "POST":
form = AuthenticationForm(data=request.POST)
if form.is_valid():
attempted_username = form.get_user().username
else:
attempted_username = form.data.get('username')
attempted_password = form.data.get('password')
# add a failed attempt for this user
failures += 1
# Create an AccessAttempt record if the login wasn't successful
# has already attempted, update the info
if attempt:
#attempt.get_data.append(query2str(request.GET.items()))
#attempt.post_data.append(query2str(request.POST.items()))
attempt.access_type = models.ACCESS_FAILED
attempt.user = attempted_username
attempt.http_accept = request.META.get('HTTP_ACCEPT', '<unknown>')
attempt.path_info = request.META.get('PATH_INFO', '<unknown>')
attempt.failures_since_start = failures
attempt.event_date = datetime.utcnow() #why do we do this?
attempt.save()
log.info(
'AXES: Repeated login failure by %s. Updating access '
'record. Count = %s', attempt.ip_address, failures)
else:
ip = get_ip(request)
ua = request.META.get('HTTP_USER_AGENT', '<unknown>')
attempt = AccessAudit()
attempt.event_date = datetime.utcnow()
attempt.doc_type = AccessAudit.__name__
attempt.access_type = models.ACCESS_FAILED
attempt.user_agent = ua
attempt.user = attempted_username
attempt.ip_address = ip
#attempt.get_data = [query2str(request.GET.items())]
#attempt.post_data= [query2str(request.POST.items())]
attempt.http_accept = request.META.get('HTTP_ACCEPT', '<unknown>')
attempt.path_info = request.META.get('PATH_INFO', '<unknown>')
attempt.failures_since_start = failures
attempt.save()
log.info('AXES: New login failure by %s. Creating access record.',
ip)
return True
def get_context_data(self, **kwargs):
context = super(LoginView, self).get_context_data(**kwargs)
context['login_form'] = AuthenticationForm(data=self.request.POST)
return context
def get(self, request):
form = AuthenticationForm()
return Response({'form': form})
def login_form():
return {'form': AuthenticationForm()}
def login(request):
if request.method == 'POST':
pass
else:
af = AuthenticationForm()
return render(request, 'users/login.html' , {'form' : af})
def get(self, request):
login_form = AuthenticationForm()
return render(request, 'votingusers/login.html', {
'login_form': login_form,
})
def home(request):
form = AuthenticationForm()
return render(request, 'todo/home.html', {'form': form})
def post(self, request, post_id):
# Variable to check if an error message is needed (non logged in user tried to interact)
needsWarning = False
# This is only here because there is never an error messaged needed with a GET request
if request.user.is_authenticated:
# The user can only interact with the post significantly if they're logged in.
postResponse = Response.objects.get_or_create(
responseUser=request.user,
responsePost=Post.objects.get(id=post_id))[0]
# Replying to the post:
if request.POST.get('reply',
"") != "Input text" and request.POST.get(
'reply', "") != "":
newPost = Post(
post_content=request.POST['reply'],
# Sorry for the long line here -- Post.objects.get(id=X) was not working :()
post_plant=Post.objects.get(id=post_id).
post_plant, # same as that of parent comment
post_parent=Post.objects.get(id=post_id),
author=request.
user, # person who sent the request is the author
pub_date=timezone.now(),
likes=0,
helpful=0, # both of the "like" values start at zero
also_questioning=0,
celebrating=0)
newPost.save()
# Reacting to the post (four different reactions):
elif request.POST.get('like', "") == "like":
postResponse.liked = not postResponse.liked # switch the status of the post
postResponse.save()
# Increment the counter if the user just liked the post
if postResponse.liked:
postToLike = Post.objects.get(id=post_id)
postToLike.likes += 1
postToLike.save()
# Decrement the counter if the user just unliked the post
else:
postToLike = Post.objects.get(id=post_id)
postToLike.likes -= 1
postToLike.save()
elif request.POST.get('helped', "") == "helped":
postResponse.helpful = not postResponse.helpful # switch the status of the post
postResponse.save()
# Increment the counter if the user just marked the post as "helpful"
if postResponse.helpful:
postToHelp = Post.objects.get(id=post_id)
postToHelp.helpful += 1
postToHelp.save()
# Decrement the counter if the user just unmarked the post as "helpful"
else:
postToHelp = Post.objects.get(id=post_id)
postToHelp.helpful -= 1
postToHelp.save()
elif request.POST.get('questioned', "") == "questioned":
postResponse.questioned = not postResponse.questioned # switch the status of the post
postResponse.save()
# Increment the counter if the user just questioned the post
if postResponse.questioned:
postToQuestion = Post.objects.get(id=post_id)
postToQuestion.also_questioning += 1
postToQuestion.save()
# Decrement the counter if the user just unliked the post
else:
postToQuestion = Post.objects.get(id=post_id)
postToQuestion.also_questioning -= 1
postToQuestion.save()
elif request.POST.get('celebrated', "") == "celebrated":
postResponse.celebrated = not postResponse.celebrated # switch the status of the post
postResponse.save()
# Increment the counter if the user just questioned the post
if postResponse.celebrated:
postToQuestion = Post.objects.get(id=post_id)
postToQuestion.celebrating += 1
postToQuestion.save()
# Decrement the counter if the user just unliked the post
else:
postToQuestion = Post.objects.get(id=post_id)
postToQuestion.celebrating -= 1
postToQuestion.save()
else:
# Alert the user that they must be logged in to interact with a post
needsWarning = True
# New context -- same as old one
post_objects = Post.objects.order_by('id')
form = AuthenticationForm()
# Adds placeholders to the fields
form.fields['username'].widget.attrs.update({
'placeholder': 'username',
})
form.fields['password'].widget.attrs.update(
{'placeholder': 'password'})
context = {
'post':
Post.objects.get(id=post_id),
'post_replies':
post_objects.filter(post_parent=Post.objects.get(id=post_id)),
'likes':
post_objects.get(id=post_id).likes,
'helpfuls':
post_objects.get(id=post_id).helpful,
'questions':
post_objects.get(id=post_id).also_questioning,
'celebrations':
post_objects.get(id=post_id).celebrating,
'form':
form,
'needsWarning':
needsWarning
}
return HttpResponse(
loader.get_template('post.html').render(context, request))
def globales(request):
form_principal = PrincipalForm(request.POST)
form1 = AuthenticationForm()
return {'form_principal': form_principal, 'form1': form1}
def index(request):
if not request.user.is_authenticated():
return {'form': AuthenticationForm(), 'reg_form': RegistrationForm()}
else:
return HttpResponseRedirect('/posts')
def login(request,
template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME):
if TEMP_DEBUG_LOGGING:
TEMP_DEBUG_FILE = open('/tmp/os-debug.log', 'a')
TEMP_DEBUG_FILE.write("\nLogin:"******"\n")
"Displays the login form and handles the login action."
if request.method == "POST":
form = AuthenticationForm(data=request.POST)
from django.contrib.auth import login
if form.is_valid():
user = form.get_user()
# Check if the user is banned
user_ob = User.objects.filter(username=user)
if len(user_ob) != 0:
if len(BanishedUser.objects.filter(user=user_ob[0])) != 0:
return json_result(
{'form_errors': {
"__all__": ["User is banned"]
}})
login(request, user)
# If this was a visitor, connect to a user
connect_visitor_to_user(request, user.id)
# Log the login
create_user_event_log(request, {"log_type": LogUserEvents.login})
if TEMP_DEBUG_LOGGING:
TEMP_DEBUG_FILE.write("Login results is user_authenticated?" +
str(request.user.is_authenticated()))
TEMP_DEBUG_FILE.close()
return json_result({
'success':
True,
'sms_can_change_password':
get_sms_can_change_password(request.user)
}) #json_success()
else:
if Settings.objects.boolean('SOFT_ENTRY_CODES'):
c = request.POST.get('entrycode', '')
code_object = EntryCode.objects.filter(code=c)
if len(code_object) <= 0:
return json_error('Invalid Entry Code')
u = User.objects.filter(username=code_object[0].username)
if len(u) <= 0:
return json_error('Entry code and user do not match')
if code_object[0].first_login:
first_login_time = UserData(user=u[0],
key='first_login',
value=time.time())
first_login_time.save()
code_object[0].first_login = False
code_object[0].save()
connect_visitor_to_user(request, u[0].id)
request.session['user_id'] = u[0].id
request.session['_auth_user_id'] = u[0].id
request.session[
'_auth_user_backend'] = 'opinion.email-auth.EmailOrUsernameModelBackend'
return json_success()
# Invalid login
if TEMP_DEBUG_LOGGING:
TEMP_DEBUG_FILE.write(
json_result({
'form_errors': errors_to_dict(form.errors)
}).content)
TEMP_DEBUG_FILE.close()
return json_result({'form_errors': errors_to_dict(form.errors)})
else:
return json_error('Invalid request.')
def user_authentication(request):
if SITE_DISABLED:
return render_to_response('core/site_disabled.html')
if not request.method == "POST":
return render_to_response(
'authentication/authentication_login_form.html',
{'form': AuthenticationForm()})
form = AuthenticationForm(data=request.POST)
username = request.POST.get('username')
password = request.POST.get('password')
# login Django, open session.
user = authenticate(username=username, password=password)
# user does not exist
if not user:
set_trylogin(username)
messages.error(request, _('Invalid username or password'))
return render_to_response(
'authentication/authentication_login_form.html', {'form': form},
context_instance=RequestContext(request))
else:
request.session['user_aux_id'] = user.id
# redirect to admin page
if user.is_staff or user.is_superuser:
login(request, user)
return HttpResponseRedirect(ADMIN_URL)
# user has not confirmed registration yet
if user.registrationprofile_set.all(
)[0].activation_key != 'ALREADY_ACTIVATED':
django_logout(request)
messages.error(
request,
_('Your account has not been confirmated yet. Please check your email and use your activation code to continue'
))
return render_to_response(
'authentication/authentication_login_form.html', {'form': form},
context_instance=RequestContext(request))
if not user.is_active:
django_logout(request)
messages.error(
request,
_('Your account has been disable. Please contact your administrator.'
))
return render_to_response(
'authentication/authentication_login_form.html', {'form': form},
context_instance=RequestContext(request))
# none restriction to login from where.
clear_login(user)
# django login, user.profile is required
login(request, user)
# choose a organization
if user.profile.organization.distinct().count() > 1:
# redirect to select org page
return HttpResponseRedirect(
reverse('authentication-select-organization'))
# just one organization
else:
# load profile user
user.profile.org_active = user.profile.organization.all()[
0] # just one org
user.profile.save()
# new role
user.groups.clear()
for role in user.get_profile().role_set.filter(
organization=user.profile.org_active):
user.groups.add(role.group)
# django login
login(request, user)
return HttpResponseRedirect('/')
def get(self, request):
context = {
'form': AuthenticationForm(),
'redirect_url': self.request.GET.get('next')
}
return render(request, self.template_name, context=context)
login(request, user)
state = "You're successfully logged in!"
try:
create_account(user)
except Exception, e:
print "Unable to create account"
print e
else:
state = "Your account is not active, please contact the site administrator"
else:
state = "Your username and/or password were incorrect."
login(request, user)
return redirect(nextPage)
else:
state = "Your username and/or password were incorrect."
return render_to_response(
"registration/login.html", {
'a_form': form,
'next': nextPage,
'state': state
},
context_instance=RequestContext(request))
except Exception as e:
print "Error authenticating form"
print e
else:
form = AuthenticationForm()
#return render_to_response("registration/login.html", {'a_form': form, 'next': nextPage, 'state': state}, context_instance=RequestContext(request))
return redirect("instagram.api.connectInstagram")
def logout(request):
auth.logout(request)
form = AuthenticationForm()
return render(request, 'signup.html', {'form': form})
def accounts(request):
return render(request, "registration/accounts.html", {
"createForm": UserCreationForm(),
"loginForm": AuthenticationForm()
})
def include_login_form(request):
from django.contrib.auth.forms import AuthenticationForm
form = AuthenticationForm()
return {"form": form}
def login_form(request):
return {'login_form': AuthenticationForm()}
def login_user(request):
if request.user.is_authenticated():
pk = signer.sign(str(request.user.pk))
return HttpResponseRedirect('./users/' + pk + '/products')
form = AuthenticationForm()
return render(request, 'lostnfound/login.html', {'form': form})
def get(self, request):
form = AuthenticationForm()
return render(request, "login/page-login.html", {
'form': form,
'message': ''
})
def get(self, request):
form = AuthenticationForm()
return render(request, 'registration/login.html', {'form': form})
def login_auth(request):
"""
登录表单验证
:param request:
:return:
"""
if request.method != "POST":
return HttpResponse("wrong method", status=403)
callback = request.session.get('callback', None)
api_key = request.session.get('api_key', None)
try:
netloc = urlparse.urlparse(callback).netloc
error, site = check_basic_params(callback, api_key, netloc)
except:
error = "callback参数有误"
if error:
return error
data = request.POST
form = AuthenticationForm(request, data=data)
if form.is_valid(): # 登录成功
user = form.get_user()
auth_token = UserTokenCache.add(request.META.get("REMOTE_ADDR"), user,
netloc) # 缓存用户账号
# 判断账号在当前站点是否已激活
if site not in user.sites.all():
request.session['auth_token'] = auth_token
return resp_activate(request, user, site)
resp = form_redirect(callback, auth_token=auth_token)
resp.set_cookie("auth_token",
auth_token) # NOTE: 这里的cookie是留到uams站点下的，并不是带给app site
history(request, user.username, '登录 %s' % site.name)
return resp
else:
# 检查是否是批量导入用户
user = Account.objects.filter(
username=request.POST.get("username", None)).first()
if user:
if not user.is_active:
error = '很抱歉，该账号已被锁定，请联系管理员'
else:
data._mutable = True
data['password'] = '******'
data._mutable = False
form = AuthenticationForm(request, data=data)
if form.is_valid(): # 验证成功，表明是批量导入的用户
error = "Your account is imported to UAMS newly, you need to reset your password."
else:
error = '用户名与密码不匹配'
else:
error = '用户名与密码不匹配'
# 跳转到登录界面
resp = form_redirect('/uams/login',
apikey=api_key,
callback=callback,
error=error)
resp.delete_cookie("auth_token")
return resp
def index(request):
form = AuthenticationForm()
context = {'form':form}
return render(request, 'users/login.html', context)
def dashboard(request):
request.session.set_test_cookie()
if request.user.is_authenticated():
act_view = {
'view_texts': get_int(request.GET, 'view_texts', 1),
'view_comments': get_int(request.GET, 'view_comments', 1),
'view_users': get_int(request.GET, 'view_users', 1),
}
paginate_by = get_int(request.GET, 'paginate', ACTIVITY_PAGINATION)
# texts with can_view_unapproved_comment perms
moderator_texts = get_texts_with_perm(request,
'can_view_unapproved_comment')
viewer_texts = get_texts_with_perm(request,
'can_view_approved_comment')
all_texts_ids = [t.id for t in moderator_texts
] + [t.id for t in viewer_texts]
span = get_among(request.GET, 'span', (
'day',
'month',
'week',
), 'week')
template_dict = {
'span':
span,
'last_texts':
get_texts_with_perm(
request,
'can_view_text').order_by('-modified')[:RECENT_TEXT_NB],
'last_comments':
Comment.objects.filter(text_version__text__in=all_texts_ids).
order_by('-created')[:RECENT_COMMENT_NB], # TODO: useful?
#'last_users' : User.objects.all().order_by('-date_joined')[:5],
}
template_dict.update(act_view)
#selected_activities = []
#[selected_activities.extend(Activity.VIEWABLE_ACTIVITIES[k]) for k in act_view.keys() if act_view[k]]
activities = get_viewable_activities(request, act_view)
if not has_perm(request, 'can_manage_workspace'):
template_dict['to_mod_profiles'] = []
else:
template_dict['to_mod_profiles'] = UserProfile.objects.filter(
user__is_active=False).filter(is_suspended=True).order_by(
'-user__date_joined')[:MODERATE_NB]
template_dict['to_mod_comments'] = Comment.objects.filter(
state='pending').filter(
text_version__text__in=moderator_texts).order_by(
'-modified')[:MODERATE_NB -
len(template_dict['to_mod_profiles'])]
activities = activities.order_by('-created')
return object_list(
request,
activities,
template_name='site/dashboard.html',
paginate_by=paginate_by,
extra_context=template_dict,
)
else:
if request.method == 'POST':
form = AuthenticationForm(request, request.POST)
if form.is_valid():
user = form.get_user()
user.backend = 'django.contrib.auth.backends.ModelBackend'
cm_login(request, user)
display_message(request, _(u"You're logged in!"))
return HttpResponseRedirect(reverse('index'))
else:
form = AuthenticationForm()
public_texts = get_texts_with_perm(
request, 'can_view_text').order_by('-modified')
template_dict = {
'form': form,
'public_texts': public_texts,
}
return render_to_response('site/non_authenticated_index.html',
template_dict,
context_instance=RequestContext(request))
def get(self, request):
return render(request, 'sign/login.html', {
'view_title': 'Login',
'login_form': AuthenticationForm()
})
def get(self, request, *args, **kwargs):
form = AuthenticationForm()
context = {
'form': form,
}
return render(request, self.template_name, context)
def index(request, template_name):
"""
Landing page for anonymous user
Sign in and Sign up functionality handled
"""
if request.user.is_authenticated():
try:
userprofile = UserProfile.objects.get(user=request.user)
except UserProfile.DoesNotExist:
return HttpResponseRedirect(reverse('registration_register'))
grades = Grade.objects.filter(
student=userprofile.user,
course__start_date__lte=datetime.now()).order_by('-date_added')
try:
course_id = MCQuestionAttempt.objects.filter(
student=request.user)[0].mcquestion.quiz.course.id
except IndexError:
course_id = None
return render_to_response('userprofile/profile.html',
context_instance=RequestContext(
request, {
'userprofile': userprofile,
'grades': grades,
'course': course_id
}))
else:
if request.POST:
form_type = request.POST['form']
if form_type == 'form1':
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)
try:
userprofile = UserProfile.objects.get(user=user)
except UserProfile.DoesNotExist:
return HttpResponseRedirect(
reverse('registration_register'))
grades = Grade.objects.filter(
student=userprofile.user,
course__start_date__lte=datetime.now()).order_by(
'-date_added')
return render_to_response(
'userprofile/profile.html',
context_instance=RequestContext(
request, {
'userprofile': userprofile,
'grades': grades
}))
else:
form = AuthenticationForm(None, request.POST)
return render_to_response('registration/login.html',
context_instance=RequestContext(
request, {'form': form}))
if form_type == 'form2':
form = UserForm(request.POST)
if form.is_valid():
user = User.objects.create_user(**form.cleaned_data)
new_user = authenticate(username=request.POST['username'],
password=request.POST['password'])
login(request, new_user)
return HttpResponseRedirect(reverse('registration_register'))
else:
form = UserForm()
return render_to_response(template_name,
context_instance=RequestContext(
request, {'form': form}))
return HttpResponseRedirect(reverse('registration_register'))
def global_nav_forms(request):
return {
'global_search_form': SearchForm(),
'global_login_form': AuthenticationForm(),
}
