def login(request):
if request.method == 'POST' or request.user.is_authenticated():
if not request.user.is_authenticated():
l = django_login(request)
# authentication failed
if not request.user.is_authenticated():
return l
next = request.REQUEST.get('next', settings.LOGIN_REDIRECT_URL)
parsed_next = urlparse.urlparse(next)
# ??? which server is the user trying to log in?
# let's keep him here :)
if parsed_next.netloc == "":
return HttpResponseRedirect(next)
# create a temporary session key (expires in 20s)
tsession = hashlib.md5(request.session.session_key).hexdigest()
TSession.objects.get_or_create(user=request.user, session_key=request.session.session_key, \
defaults={'expire_date' : timezone.now() + datetime.timedelta(seconds=20),
'tsession_key' : tsession, })
return HttpResponseRedirect(
'%s://%s/sso/login/?tsessionid=%s&next=%s' %
(parsed_next.scheme, parsed_next.netloc, tsession,
parsed_next.path))
else:
return django_login(request)
def authorize_login(request):
initial = {}
login_url = 'get_login_view'
if request.method == "POST":
form = curry(Login, request)
else:
form = curry(Login, initial=initial)
extra_context = {'redirect_field_name': REDIRECT_FIELD_NAME}
if request.is_ajax():
template_name = 'auth/_login.html'
extra_context['hide'] = True
else:
template_name = login_url
django_login(request,
template_name=login_url,
authentication_form=form,
extra_context=extra_context)
if request.user.is_authenticated():
set_session_from_user(request, request.user)
redirect = request.POST.get('next', None) or login_url
return shortcuts.redirect(redirect)
def authorize_login(request):
initial = {}
login_url = 'get_login_view'
if request.method == "POST":
form = curry(Login, request)
else:
form = curry(Login, initial=initial)
extra_context = {'redirect_field_name': REDIRECT_FIELD_NAME}
if request.is_ajax():
template_name = 'auth/_login.html'
extra_context['hide'] = True
else:
template_name = login_url
django_login(request,
template_name=login_url,
authentication_form=form,
extra_context=extra_context)
if request.user.is_authenticated():
set_session_from_user(request, request.user)
redirect = request.POST.get('next', None) or login_url
return shortcuts.redirect(redirect)
def login(request, template_name='registration/login.html'):
if request.method == 'GET':
response = django_login(request, template_name=template_name)
elif request.method == 'POST':
response = django_login(request, template_name=template_name)
# 정상적으로 로그인이 됐을때
if response.status_code == 302:
# profile = Profile.objects.get(user=request.user)
if not request.user.signup_approved:
messages.error(request, "승인된 후 로그인이 가능합니다.")
return HttpResponseRedirect("/accounts/logout")
return response
def login(request):
"""
Atentica usuarios con un formulario.
"""
error = False
email = request.GET.get('email', None)
DISPLAY_LOGIN_HELP_TEXT = request.session.get(
'DISPLAY_LOGIN_HELP_TEXT', False)
DISPLAY_LOGIN_PREPOPULATE_EMAIL = request.session.get(
'DISPLAY_LOGIN_PREPOPULATE_EMAIL', '')
if request.method == "POST":
form = AuthenticationForm(data=request.POST)
next_ = request.POST.get('next', '/')
if form.is_valid():
user = form.get_user()
django_login(request, user)
user.last_login = datetime.now()
user.save()
redirect_fallback = reverse('actividades')
if user.is_staff :
redirect_fallback = reverse('dash_board')
# delete session helpers
try:
del request.session['DISPLAY_LOGIN_HELP_TEXT']
except:
pass
try:
del request.session['DISPLAY_LOGIN_PREPOPULATE_EMAIL']
except:
pass
next_ = request.POST.get('next', redirect_fallback)
return HttpResponseRedirect(next_)
else:
form = AuthenticationForm(
initial={'username': DISPLAY_LOGIN_PREPOPULATE_EMAIL}
)
next_ = request.GET.get('next', '')
data = {
'DISPLAY_LOGIN_HELP_TEXT': DISPLAY_LOGIN_HELP_TEXT,
"form": form,
"next": next_,
"email": email
}
return render(request, 'ingresar.html', data)
def login(request):
"""
This login view is a wrapper for the default login view in Django. This view checks if the user
is already authenticated and if so, it redirects the user straight to the page he/she was
trying to access. If no page is accessed, the user is redirected to default address.
If the user has not yet been authenticated, this view will call the default view in Django.
"""
if request.user.is_authenticated():
# User is authenticated so we'll just redirect. The following checks for the redirect url
# are borrowed from django.contrib.auth.views.login.
redirect_to = request.REQUEST.get(REDIRECT_FIELD_NAME, '')
netloc = urlparse.urlparse(redirect_to)[1]
# Use default setting if redirect_to is empty
if not redirect_to:
redirect_to = settings.LOGIN_REDIRECT_URL
# Security check -- don't allow redirection to a different host.
elif netloc and netloc != request.get_host():
redirect_to = settings.LOGIN_REDIRECT_URL
return redirect(redirect_to)
return django_login(request, template_name="aaltoplus/login.html")
def login(request):
""" view that renders the login """
# If the form has been submitted...
template_name = "accounts/login.html"
return django_login(request,
authentication_form=AuthenticationForm,
template_name=template_name)
def login(request):
"""
Wraps the default login view in Django. Additionally redirects already
authenticated users automatically to the target.
"""
if request.user.is_authenticated():
redirect_to = request.POST.get(REDIRECT_FIELD_NAME,
request.GET.get(REDIRECT_FIELD_NAME, ''))
if not is_safe_url(url=redirect_to, host=request.get_host()):
redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL)
return HttpResponseRedirect(redirect_to)
return django_login(
request,
template_name="userprofile/login.html",
extra_context={
'shibboleth_login': '******' in settings.INSTALLED_APPS,
'mooc_login': '******' in settings.INSTALLED_APPS,
'login_title_text': settings_text(request, 'LOGIN_TITLE_TEXT'),
'login_body_text': settings_text(request, 'LOGIN_BODY_TEXT'),
'login_button_text': settings_text(request, 'LOGIN_BUTTON_TEXT'),
'shibboleth_title_text': settings_text(request, 'SHIBBOLETH_TITLE_TEXT'),
'shibboleth_body_text': settings_text(request, 'SHIBBOLETH_BODY_TEXT'),
'shibboleth_button_text': settings_text(request, 'SHIBBOLETH_BUTTON_TEXT'),
'mooc_title_text': settings_text(request, 'MOOC_TITLE_TEXT'),
'mooc_body_text': settings_text(request, 'MOOC_BODY_TEXT'),
}
)
def login(request):
""" Logs a user in using the :class:`~openstack_auth.forms.Login` form. """
# Get our initial region for the form.
initial = {}
current_region = request.session.get("region_endpoint", None)
requested_region = request.GET.get("region", None)
regions = dict(getattr(settings, "AVAILABLE_REGIONS", []))
if requested_region in regions and requested_region != current_region:
initial.update({"region": requested_region})
if request.method == "POST":
form = curry(Login, request)
else:
form = curry(Login, initial=initial)
extra_context = {"redirect_field_name": REDIRECT_FIELD_NAME}
if request.is_ajax():
template_name = "auth/_login.html"
extra_context["hide"] = True
else:
template_name = "auth/login.html"
res = django_login(request, template_name=template_name, authentication_form=form, extra_context=extra_context)
# Set the session data here because django's session key rotation
# will erase it if we set it earlier.
if request.user.is_authenticated():
set_session_from_user(request, request.user)
regions = dict(Login.get_region_choices())
region = request.user.endpoint
region_name = regions.get(region)
request.session["region_endpoint"] = region
request.session["region_name"] = region_name
return res
def login(request, *args, **kwargs):
if request.method == 'GET':
if request.user.is_authenticated():
redirect_to = kwargs.get('next', settings.LOGIN_REDIRECT_URL)
redirect_to = request.GET.get('next', redirect_to)
return redirect(redirect_to)
request.session.set_test_cookie()
if request.method == 'POST':
form = AuthenticationForm(request, data=request.POST)
if form.is_valid():
if getattr(settings, 'NOPASSWORD_USE_EMAIL', False):
code = LoginCode.objects.filter(
**{
'user__%s' % get_username_field():
request.POST.get('email').lower()
})[0]
else:
code = LoginCode.objects.filter(
**{
'user__%s' % get_username_field():
request.POST.get('username')
})[0]
code.next = request.POST.get('next')
code.save()
code.send_login_code(
secure=request.is_secure(),
host=request.get_host(),
)
return render(request, 'registration/sent_mail.html')
return django_login(request, authentication_form=AuthenticationForm)
def _login(req, domain, domain_type, template_name, domain_context=None):
from corehq.apps.registration.views import get_domain_context
if req.user.is_authenticated() and req.method != "POST":
redirect_to = req.REQUEST.get('next', '')
if redirect_to:
return HttpResponseRedirect(redirect_to)
if not domain:
return HttpResponseRedirect(reverse('homepage'))
else:
return HttpResponseRedirect(reverse('domain_homepage', args=[domain]))
if req.method == 'POST' and domain and '@' not in req.POST.get('username', '@'):
req.POST._mutable = True
req.POST['username'] = format_username(req.POST['username'], domain)
req.POST._mutable = False
req.base_template = settings.BASE_TEMPLATE
context = domain_context or get_domain_context(domain_type)
context['domain'] = domain
if domain:
context['next'] = req.REQUEST.get('next', '/a/%s/' % domain)
return django_login(req, template_name=template_name,
authentication_form=EmailAuthenticationForm if not domain else CloudCareAuthenticationForm,
extra_context=context)
def login(request, extra_context=None):
"""
This login function is a wrapper around django's login() for the purpose
of providing a notification if the user's password has been cleared. The
warning will be triggered if the password field has been set to something
which is not recognized as a valid password hash.
"""
if request.method == "POST":
form = AuthenticationForm(request, data=request.POST)
username = form.data.get('username')
user = User.objects.filter(username=username).first()
if user:
try:
identify_hasher(user.password)
except ValueError:
extra_context = {
"alert":
"Note: Your password has been cleared because "
"of possible password leakage. "
"Please use the password reset link below "
"to set a new password for your account.",
}
return django_login(request, extra_context=extra_context)
def login(request):
if getattr(request, 'limited', False):
messages = [
"Too many requests on {path}. Page forbidden.".format(
path=request.path),
"From IP: %s" % get_client_ip(request)
]
if request.method == "POST" and request.POST.get('username'):
messages.append("Last try with username: %s" %
request.POST.get('username'))
logger.error("\n".join(messages))
return render_to_response("429-limited.html", status=429)
logged = request.user.is_authenticated() and request.user.username
response = django_login(
request,
template_name="login.html",
extra_context={
'logo_consorzio': settings.TRANSPARENT_LOGO,
'nome_consorzio': settings.LICENSE_OWNER
},
authentication_form=AuthenticationFormWrapped,
)
if request.user.is_authenticated(
) and request.user.username != logged: # just logged in
request.session["userAgent"] = request.META.get('HTTP_USER_AGENT')
logger.debug("Login for %s" % request.user)
logAction('L', description='Accesso effettuato', user=request.user)
else:
if request.method == "POST":
logger.debug("Login attempt failed")
if request.is_ajax():
return HttpResponseServerError("Please login")
return response
def login(req, template_name="webapp/login.html"):
'''Login to rapidsms'''
# this view, and the one below, is overridden because
# we need to set the base template to use somewhere
# somewhere that the login page can access it.
req.base_template = settings.BASE_TEMPLATE
return django_login(req, **{"template_name": template_name})
def login(request):
"""
Wraps the default login view in Django. Additionally redirects already
authenticated users automatically to the target.
"""
if request.user.is_authenticated():
redirect_to = request.POST.get(REDIRECT_FIELD_NAME,
request.GET.get(REDIRECT_FIELD_NAME, ''))
if not is_safe_url(url=redirect_to, host=request.get_host()):
redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL)
return HttpResponseRedirect(redirect_to)
return django_login(
request,
template_name="userprofile/login.html",
extra_context={
'shibboleth_login': '******' in settings.INSTALLED_APPS,
'mooc_login': '******' in settings.INSTALLED_APPS,
'login_title_text': settings_text('LOGIN_TITLE_TEXT'),
'login_body_text': settings_text('LOGIN_BODY_TEXT'),
'login_button_text': settings_text('LOGIN_BUTTON_TEXT'),
'shibboleth_title_text': settings_text('SHIBBOLETH_TITLE_TEXT'),
'shibboleth_body_text': settings_text('SHIBBOLETH_BODY_TEXT'),
'shibboleth_button_text': settings_text('SHIBBOLETH_BUTTON_TEXT'),
'mooc_title_text': settings_text('MOOC_TITLE_TEXT'),
'mooc_body_text': settings_text('MOOC_BODY_TEXT'),
}
)
def login(request):
if getattr(request, 'limited', False):
messages = ["Too many requests on {path}. Page forbidden.".format(path=request.path),
"From IP: %s" % get_client_ip(request)]
if request.method == "POST" and request.POST.get('username'):
messages.append("Last try with username: %s" % request.POST.get('username'))
logger.error("\n".join(messages))
return render_to_response("429-limited.html", status=429)
logged = request.user.is_authenticated() and request.user.username
response = django_login(request,
template_name="login.html",
extra_context={'logo_consorzio': settings.TRANSPARENT_LOGO,
'nome_consorzio': settings.LICENSE_OWNER
},
authentication_form=AuthenticationFormWrapped,
)
if request.user.is_authenticated() and request.user.username != logged: # just logged in
request.session["userAgent"] = request.META.get('HTTP_USER_AGENT')
logger.debug("Login for %s" % request.user)
logAction('L', description='Accesso effettuato', user=request.user)
else:
if request.method == "POST":
logger.debug("Login attempt failed")
if request.is_ajax():
return HttpResponseServerError("Please login")
return response
def _login(req, domain, domain_type, template_name, domain_context=None):
from corehq.apps.registration.views import get_domain_context
if req.user.is_authenticated() and req.method != "POST":
redirect_to = req.REQUEST.get('next', '')
if redirect_to:
return HttpResponseRedirect(redirect_to)
if not domain:
return HttpResponseRedirect(reverse('homepage'))
else:
return HttpResponseRedirect(
reverse('domain_homepage', args=[domain]))
if req.method == 'POST' and domain and '@' not in req.POST.get(
'username', '@'):
req.POST._mutable = True
req.POST['username'] = format_username(req.POST['username'], domain)
req.POST._mutable = False
req.base_template = settings.BASE_TEMPLATE
context = domain_context or get_domain_context(domain_type)
context['domain'] = domain
if domain:
context['next'] = req.REQUEST.get('next', '/a/%s/' % domain)
return django_login(req,
template_name=template_name,
authentication_form=EmailAuthenticationForm
if not domain else CloudCareAuthenticationForm,
extra_context=context)
def _login(req, domain_name, template_name):
if req.user.is_authenticated() and req.method != "POST":
redirect_to = req.REQUEST.get('next', '')
if redirect_to:
return HttpResponseRedirect(redirect_to)
if not domain_name:
return HttpResponseRedirect(reverse('homepage'))
else:
return HttpResponseRedirect(
reverse('domain_homepage', args=[domain_name]))
if req.method == 'POST' and domain_name and '@' not in req.POST.get(
'username', '@'):
req.POST._mutable = True
req.POST['username'] = format_username(req.POST['username'],
domain_name)
req.POST._mutable = False
req.base_template = settings.BASE_TEMPLATE
context = {}
if domain_name:
domain = Domain.get_by_name(domain_name)
context.update({
'domain': domain_name,
'hr_name': domain.display_name() if domain else domain_name,
'next': req.REQUEST.get('next', '/a/%s/' % domain),
})
authentication_form = EmailAuthenticationForm if not domain_name else CloudCareAuthenticationForm
return django_login(req,
template_name=template_name,
authentication_form=authentication_form,
extra_context=context)
def login(request, *args, **kwargs):
response = django_login(request, *args, **kwargs)
if request.user.is_authenticated():
messages.info(request, "Logged in successfully.")
elif request.method == 'POST': # Not quite ideal; FIXME
messages.error(request, "Login Failed.")
return response
def _login(req, domain, template_name):
if req.user.is_authenticated() and req.method != "POST":
redirect_to = req.REQUEST.get('next', '')
if redirect_to:
return HttpResponseRedirect(redirect_to)
if not domain:
return HttpResponseRedirect(reverse('homepage'))
else:
return HttpResponseRedirect(reverse('domain_homepage', args=[domain]))
if req.method == 'POST' and domain and '@' not in req.POST.get('username', '@'):
req.POST._mutable = True
req.POST['username'] = format_username(req.POST['username'], domain)
req.POST._mutable = False
req.base_template = settings.BASE_TEMPLATE
context = {}
if domain:
context.update({
'domain': domain,
'next': req.REQUEST.get('next', '/a/%s/' % domain),
})
return django_login(req, template_name=template_name,
authentication_form=EmailAuthenticationForm if not domain else CloudCareAuthenticationForm,
extra_context=context)
def login_user(request):
if request.method == 'POST' and (not request.POST.get('remember_me', None)):
request.session.set_expiry(0)
return django_login(request,
template_name="log/login.html",
authentication_form=AuthenticationForm)
def login(request, template_name="core/login.html"):
'''Login to cis'''
# this view, and the one below, is overridden because
# we need to set the base template to use somewhere
# somewhere that the login page can access it.
# request.base_template = settings.BASE_TEMPLATE
return django_login(request, **{"template_name" : template_name})
def login(request):
if request.method == 'POST':
form = AuthenticationForm(data=request.POST)
if form.is_valid():
return render(request, 'registration/sent_mail.html')
return django_login(request, authentication_form=AuthenticationForm)
def login(request, *args, **kwargs):
if request.method == 'GET':
if request.user.is_authenticated():
redirect_to = kwargs.get('next', settings.LOGIN_REDIRECT_URL )
redirect_to = request.GET.get('next', redirect_to)
return redirect(redirect_to)
request.session.set_test_cookie()
if request.method == 'POST':
form = AuthenticationForm(request, data=request.POST)
if form.is_valid():
if getattr(settings, 'NOPASSWORD_USE_EMAIL', False):
code = LoginCode.objects.filter(**{
'user__%s' % get_username_field(): request.POST.get('email').lower()
})[0]
else:
code = LoginCode.objects.filter(**{
'user__%s' % get_username_field(): request.POST.get('username')
})[0]
code.next = request.POST.get('next')
code.save()
code.send_login_code(
secure=request.is_secure(),
host=request.get_host(),
)
return render(request, 'registration/sent_mail.html')
return django_login(request, authentication_form=AuthenticationForm)
def login(request, template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
extra_context=None):
return django_login(request, template_name,
redirect_field_name,
authentication_form,
extra_context)
def login(request):
if request.user.is_authenticated():
return HttpResponseRedirect("/")
response = django_login(request, template_name='accounts/login.html', authentication_form=LoginForm)
return response
def login(request):
"""
Login an account.
"""
context = {}
utilities.get_message(request, context)
return django_login(request, 'accounts/login.html', extra_context=context)
def authorize_client_login(request):
login_url = 'get_login_client_view'
translation.activate('zh')
request.LANGUAGE_CODE = 'zh'
form = curry(Login, request)
extra_context = {'redirect_field_name': REDIRECT_FIELD_NAME}
django_login(request,
template_name=login_url,
authentication_form=form,
extra_context=extra_context)
if request.user.is_authenticated():
set_session_from_user(request, request.user)
return shortcuts.redirect('get_client_instances')
else:
return shortcuts.redirect(login_url)
def landing_page(req, template_name="home.html"):
# this view, and the one below, is overridden because
# we need to set the base template to use somewhere
# somewhere that the login page can access it.
if req.user.is_authenticated():
return HttpResponseRedirect(reverse('homepage'))
req.base_template = settings.BASE_TEMPLATE
return django_login(req, template_name=template_name, authentication_form=EmailAuthenticationForm)
def default(request):
"""Unauthenticated default view
Wraps django login view so we redirect to logged in page when authenticated
"""
if request.user.is_authenticated():
return redirect(settings.LOGIN_REDIRECT_URL)
return django_login(request, template_name="default.html")
def authorize_client_login(request):
login_url = 'get_login_client_view'
translation.activate('zh')
request.LANGUAGE_CODE = 'zh'
form = curry(Login, request)
extra_context = {'redirect_field_name': REDIRECT_FIELD_NAME}
django_login(request,
template_name=login_url,
authentication_form=form,
extra_context=extra_context)
if request.user.is_authenticated():
set_session_from_user(request, request.user)
return shortcuts.redirect('get_client_instances')
else:
return shortcuts.redirect(login_url)
def login(req, template_name="webapp/login.html"):
'''Login to rapidsms'''
req.base_template = "webapp/layout.html"
return django_login(req, **{"template_name" : template_name})
def login(request):
if request.method == 'GET' and not 'next' in request.GET:
url = reverse('simpleauth:login')
next_url = request.META.get('HTTP_REFERER')
if next_url:
next_url = urllib.parse.quote(next_url)
url = "{}?next={}".format(url, next_url)
return redirect(url)
return django_login(request)
def login(request):
data = {
'template_name': 'registration/login.html',
'authentication_form': LoginForm
}
if request.user.is_authenticated():
return HttpResponseRedirect('/profile')
else:
return django_login(request, **data)
def my_login(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/')
c = {'ask_form': AskForm(),
'title': 'Login'
}
return django_login(request, extra_context=c)
def login(request):
bootstrap_token = None
if settings.DEBUG:
from iconcollections.models import Collection
collections = Collection.objects.filter(build_name="myicons").values_list("token", flat=True)
if collections:
bootstrap_token = collections[0]
return django_login(request, template_name="login.html", extra_context={"bootstrap": bootstrap_token})
def login(request):
next = request.POST.get("next", '')
if 'next=' in next:
next = next[next.rindex('next=') + 5:]
rv = django_login(request, authentication_form=login_form)
##TODO: flash a message here that you've changed your password
if type(rv) == HttpResponseRedirect:
return HttpResponseRedirect(next)
return rv
def login(request, *args, **kwargs):
if request.method == 'POST':
# If we have 'remember_me' checked, user session
# will never expire
if not request.POST.get('remember_me', None):
request.session.set_expiry(0)
# Dispatch to Django's built-in login view
return django_login(request, *args, **kwargs)
def login(request):
if request.user.is_authenticated():
return HttpResponseRedirect("/")
response = django_login(request,
template_name='accounts/login.html',
authentication_form=LoginForm)
return response
def landing_page(req, template_name="home.html"):
# this view, and the one below, is overridden because
# we need to set the base template to use somewhere
# somewhere that the login page can access it.
if req.user.is_authenticated():
return HttpResponseRedirect(reverse('homepage'))
req.base_template = settings.BASE_TEMPLATE
return django_login(req,
template_name=template_name,
authentication_form=EmailAuthenticationForm)
def login(request):
next = request.POST.get("next", '')
if 'next=' in next:
next = next[next.rindex('next=')+5:]
rv = django_login(request,
authentication_form=login_form)
##TODO: flash a message here that you've changed your password
if type(rv) == HttpResponseRedirect:
return HttpResponseRedirect(next)
return rv
def login(request, template_name='login_page.html', auth_form=LoginForm):
# Sanity check: this person already logged in.
if request.user.is_authenticated():
return HttpResponseRedirect('/')
if request.method == 'POST':
form = auth_form(data=request.POST)
if form.is_valid():
django_login(request) #, authentication_form=auth_form)
else:
form = auth_form()
c = RequestContext(request, {'login_form': form})
return render_to_response(template_name, context_instance=c)
def login(request):
if request.method == 'POST':
form = AuthenticationForm(data=request.POST)
if form.is_valid():
code = LoginCode.objects.filter(**{'user__%s' % USERNAME_FIELD: request.POST.get('username')})[0]
code.next = request.GET.get('next')
code.save()
code.send_login_email()
return render(request, 'registration/sent_mail.html')
return django_login(request, authentication_form=AuthenticationForm)
def login(request, *args, **kwargs):
if request.method == 'POST':
if not request.POST.get('remember_me', None):
request.session.set_expiry(0)
kwargs.update({
'template_name': 'registration/login.html',
'authentication_form': AuthenticationForm
})
return django_login(request, *args, **kwargs)
def login(request):
if request.method == "POST":
form = AuthenticationForm(data=request.POST)
if form.is_valid():
code = LoginCode.objects.filter(**{"user__%s" % get_username_field(): request.POST.get("username")})[0]
code.next = request.GET.get("next")
code.save()
code.send_login_code(secure=request.is_secure(), host=request.get_host())
return render(request, "registration/sent_mail.html")
return django_login(request, authentication_form=AuthenticationForm)
def login(request):
bootstrap_token = None
if settings.DEBUG:
from iconcollections.models import Collection
collections = Collection.objects.filter(build_name="myicons").values_list('token', flat=True)
if collections:
bootstrap_token = collections[0]
return django_login(request,
template_name='login.html',
extra_context={'bootstrap': bootstrap_token})
def login(req, template_name="rapidsms/login.html"):
response = django_login(req, **{"template_name" : template_name})
if getattr(settings, 'ENABLE_AUDITLOG', False):
try:
from auditlog.utils import audit_log
if req.user.is_authenticated():
log_dict = {'request': req, 'logtype': 'system', 'action':'login',
'detail':'User logged in %s:%s' % (req.user.id, req.user.username) }
audit_log(log_dict)
except ImportError:
pass
return response
def login(request):
if request.user.is_authenticated():
return redirect(_user_detail_url(request.user))
else:
return django_login(
request,
template_name="rheia/login.html",
extra_context={
"title": defaults.APP_NAME,
"site_header": defaults.APP_NAME + " Login"
}
)
def login(req, template_name="rapidsms/login.html"):
response = django_login(req, **{"template_name" : template_name})
if getattr(settings, 'ENABLE_AUDITLOG', False):
try:
from auditlog.utils import audit_log
if req.user.is_authenticated():
log_dict = {'request': req, 'logtype': 'system', 'action':'login',
'detail':'User logged in %s:%s' % (req.user.id, req.user.username) }
audit_log(log_dict)
except:
pass
return response
def login(request, fmt='html'):
if "username" in request.POST and "password" in request.POST:
un = request.POST["username"]
pw = request.POST["password"]
key = un
val = encrypt_pass_cookie(pw)
response = django_login(request, template_name='accounts/login.html')
response.set_signed_cookie(key,
val,
salt=settings.COOKIE_SIGNED_SALT,
max_age=settings.COOKIE_MAXAGE,
secure=settings.COOKIE_SECURE,
httponly=True)
# insert login history
ulin = Ulin()
ulin.accup_user_id = get_object_or_404(Accuser, Q(accup_user_name=un))
ulin.login_ip = request.META.get('REMOTE_ADDR')
ulin.save()
else:
response = django_login(request, template_name='accounts/login.html')
return response
def login(request):
# the template is only used to show errors
response = django_login(
request,
template_name='accounts/login_form.html',
authentication_form=AuthenticationForm,
)
if request.is_ajax():
if response.status_code == 302:
# it worked!
return user_json(request)
return response
def login(request):
# the template is only used to show errors
response = django_login(
request,
template_name='accounts/login_form.html',
authentication_form=AuthenticationForm,
)
if request.is_ajax():
if response.status_code == 302:
# it worked!
return user_json(request)
return response
def login(request):
if request.user.is_authenticated():
if request.GET.get('next'):
return redirect(request.GET.get('next'))
else:
return redirect('accounts:profile')
if request.GET.get('deeplink'):
message = "Welcome! You must sign in at this point and will then be redirected to the requested page."
messages.add_message(request, messages.SUCCESS, message)
logger.debug(message)
return django_login(request)
def login(request,
template_name='smartmin/users/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
current_app=None,
extra_context=None):
lockout_timeout = getattr(settings, 'USER_LOCKOUT_TIMEOUT', 10)
failed_login_limit = getattr(settings, 'USER_FAILED_LOGIN_LIMIT', 5)
allow_email_recovery = getattr(settings, 'USER_ALLOW_EMAIL_RECOVERY', True)
if request.method == "POST":
if 'username' in request.POST and 'password' in request.POST:
# we are using AuthenticationForm in which username is CharField with strip=True that automatically strips
# whitespace characters, we need to copy that behaviour
username = request.POST['username'].strip()
user = get_user_model().objects.filter(
username__iexact=username).first()
# this could be a valid login by a user
if user:
# incorrect password? create a failed login token
valid_password = user.check_password(request.POST['password'])
if not valid_password:
FailedLogin.objects.create(user=user)
bad_interval = timezone.now() - timedelta(
minutes=lockout_timeout)
failures = FailedLogin.objects.filter(user=user)
# if the failures reset after a period of time, then limit our query to that interval
if lockout_timeout > 0:
failures = failures.filter(failed_on__gt=bad_interval)
# if there are too many failed logins, take them to the failed page
if len(failures) >= failed_login_limit:
return HttpResponseRedirect(reverse('users.user_failed'))
# delete failed logins if the password is valid
elif valid_password:
FailedLogin.objects.filter(user=user).delete()
return django_login(
request,
template_name='smartmin/users/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
current_app=None,
extra_context=dict(allow_email_recovery=allow_email_recovery))
def login(
request,
template_name="smartmin/users/login.html",
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
current_app=None,
extra_context=None,
):
lockout_timeout = getattr(settings, "USER_LOCKOUT_TIMEOUT", 10)
failed_login_limit = getattr(settings, "USER_FAILED_LOGIN_LIMIT", 5)
allow_email_recovery = getattr(settings, "USER_ALLOW_EMAIL_RECOVERY", True)
if request.method == "POST":
if "username" in request.REQUEST and "password" in request.REQUEST:
username = request.REQUEST["username"]
user = User.objects.filter(username=username)
# this could be a valid login by a user
if user:
user = user[0]
# incorrect password? create a failed login token
valid_password = user.check_password(request.REQUEST["password"])
if not valid_password:
FailedLogin.objects.create(user=user)
bad_interval = timezone.now() - timedelta(minutes=lockout_timeout)
failures = FailedLogin.objects.filter(user=user)
# if the failures reset after a period of time, then limit our query to that interval
if lockout_timeout > 0:
failures = failures.filter(failed_on__gt=bad_interval)
# if there are too many failed logins, take them to the failed page
if len(failures) >= failed_login_limit:
return HttpResponseRedirect(reverse("users.user_failed"))
# delete failed logins if the password is valid
elif valid_password:
FailedLogin.objects.filter(user=user).delete()
return django_login(
request,
template_name="smartmin/users/login.html",
redirect_field_name=REDIRECT_FIELD_NAME,
authentication_form=AuthenticationForm,
current_app=None,
extra_context=dict(allow_email_recovery=allow_email_recovery),
)
def login(request,
template_name='registration/login.html',
redirect_field_name=REDIRECT_FIELD_NAME,
redirect_authenticated=None,
authentication_form=AuthenticationForm):
print "========= In apps/auth/login ============"
context = RequestContext(request)
form = authentication_form(data=request.POST)
if request.method == "POST":
print "username: "******"NOT ACTIVATED YET"
user_name = user.username
return render_to_response('base_login.html', {
'form': form,
'username': user_name,
'need_activation': True,
},
context_instance=RequestContext(request))
return django_login(request,
template_name=template_name,
redirect_field_name=redirect_field_name,
authentication_form=authentication_form)
def login(request, *args, **kwargs):
attempts_key = 'login_attempts'
attempts = request.session.get(attempts_key, (0, None))
if request.method == 'POST':
attempts = (attempts[0] + 1, time.time())
request.session[attempts_key] = attempts
kwargs['authentication_form'] = forms.LoginForm
response = django_login(request, *args, **kwargs)
if response.status_code == 302:
try:
del request.session[attempts_key]
except KeyError:
pass
return response
def login(request):
if request.method == 'POST':
form = AuthenticationForm(data=request.POST)
if form.is_valid():
code = LoginCode.objects.filter(**{
'user__%s' % get_username_field():
request.POST.get('username')
})[0]
code.next = request.GET.get('next')
code.save()
code.send_login_email()
return render(request, 'registration/sent_mail.html')
return django_login(request, authentication_form=AuthenticationForm)
def login(req, template_name="webapp/login.html"):
'''Login to rapidsms'''
# this view, and the one below, is overridden because
# we need to set the base template to use somewhere
# somewhere that the login page can access it.
req.base_template = settings.BASE_TEMPLATE
#area={}
#locs=Report.objects.values_list('location', flat=True).distinct()
#req.session['locs']=locs
#req.session['dst']=[ dst for dst in Location.objects.filter(id__in=LocationShorthand.objects.filter(original__in=locs).values_list('district', flat=True).distinct())]
#req.session['prv']=[ prov for prov in Location.objects.filter(id__in=LocationShorthand.objects.filter(original__in=locs).values_list('province', flat=True).distinct())]
#req.session['important']=get_important_stats(req, filters)
return django_login(req, **{"template_name" : template_name})
