def context(**extra):
return dict(
{
'plus_id': getattr(settings, 'SOCIAL_AUTH_GOOGLE_PLUS_KEY', None),
'plus_scope': load_backends(settings.AUTHENTICATION_BACKENDS),
'available_backends': load_backends(
settings.AUTHENTICATION_BACKENDS)
}, **extra)
def test_login_redirect(self):
try:
# psa creates copy of settings...
orig_backends = social_django.utils.BACKENDS
social_django.utils.BACKENDS = (
"social_core.backends.github.GithubOAuth2",
"weblate.accounts.auth.WeblateUserBackend",
)
load_backends(social_django.utils.BACKENDS, force_load=True)
response = self.client.get(reverse("login"))
self.assertContains(
response, "Redirecting you to the authentication provider.")
finally:
social_django.utils.BACKENDS = orig_backends
def get_context_data(self, **kwargs):
"""Load up the default data to show in the display form."""
# user_form = UserForm(request.POST, instance=request.user)
# username = self.kwargs.get("username")
username = self.kwargs.get("pk")
if username:
try:
user = get_object_or_404(SocialProfile, username=username)
except Exception as e:
try:
user = get_object_or_404(SocialProfile, pk=username)
except Exception as e:
user = self.request.user
elif self.request.user.is_authenticated:
user = self.request.user
else:
raise Http404 # Case where user gets to this view anonymously for non-existent user
if user != self.request.user:
raise PermissionDenied()
sp_form = SocialProfileForm(instance=user)
return {
"user": user,
"available_backends":
load_backends(settings.AUTHENTICATION_BACKENDS),
"sp_form": sp_form,
}
def test_backend_icon_name(self):
rendered = self.TEMPLATE_BACKEND_ICON_NAME.render(
Context({
"available_backends":
load_backends(settings.AUTHENTICATION_BACKENDS)
}))
self.assertEqual(rendered, "google twitter ")
def register(request):
"""Registration form."""
captcha = None
if request.method == 'POST':
form = RegistrationForm(request, request.POST)
if settings.REGISTRATION_CAPTCHA:
captcha = CaptchaForm(request, form, request.POST)
if ((captcha is None or captcha.is_valid()) and form.is_valid()
and settings.REGISTRATION_OPEN):
if form.cleaned_data['email_user']:
notify_account_activity(form.cleaned_data['email_user'],
request, 'connect')
return fake_email_sent(request)
store_userid(request)
return social_complete(request, 'email')
else:
form = RegistrationForm(request)
if settings.REGISTRATION_CAPTCHA:
captcha = CaptchaForm(request)
backends = set(load_backends(social_django.utils.BACKENDS).keys())
# Redirect if there is only one backend
if len(backends) == 1 and 'email' not in backends:
return redirect_single(request, backends.pop())
return render(
request, 'accounts/register.html', {
'registration_email': 'email' in backends,
'registration_backends': backends - set(['email']),
'title': _('User registration'),
'form': form,
'captcha_form': captcha,
})
def get_context_data(self, **kwargs):
"""Load up the default data to show in the display form."""
username = self.kwargs.get("username")
if username:
try:
user = get_object_or_404(SocialProfile, username=username)
except Exception as e:
try:
user = get_object_or_404(SocialProfile, pk=username)
except Exception as e:
user = get_object_or_404(SocialProfile,
pk=self.request.user.pk)
elif self.request.user.is_authenticated:
user = get_object_or_404(SocialProfile, pk=self.request.user.pk)
else:
raise Http404 # Case where user gets to this view anonymously for non-existent user
if self.request.user != user and user.visible:
raise Http404 # Case where user set to be private
return {
"user": user,
"available_backends":
load_backends(settings.AUTHENTICATION_BACKENDS),
}
def weblate_login(request):
'''
Login handler, just wrapper around login.
'''
# Redirect logged in users to profile
if request.user.is_authenticated:
return redirect_profile()
# Redirect if there is only one backend
auth_backends = list(load_backends(BACKENDS).keys())
if len(auth_backends) == 1 and auth_backends[0] != 'email':
return redirect('social:begin', auth_backends[0])
return auth_views.login(
request,
template_name='accounts/login.html',
authentication_form=LoginForm,
extra_context={
'login_backends': [
x for x in auth_backends if x != 'email'
],
'can_reset': 'email' in auth_backends,
'title': _('Login'),
}
)
def register(request):
"""Registration form."""
captcha_form = None
if request.method == 'POST':
form = RegistrationForm(request.POST)
if settings.REGISTRATION_CAPTCHA:
captcha_form = CaptchaForm(request, request.POST)
if ((captcha_form is None or captcha_form.is_valid())
and form.is_valid() and settings.REGISTRATION_OPEN):
if form.cleaned_data['email_user']:
notify_account_activity(form.cleaned_data['email_user'],
request, 'connect')
request.session['registration-email-sent'] = True
return redirect('email-sent')
return complete(request, 'email')
else:
form = RegistrationForm()
if settings.REGISTRATION_CAPTCHA:
captcha_form = CaptchaForm(request)
backends = set(load_backends(BACKENDS).keys())
# Redirect if there is only one backend
if len(backends) == 1 and 'email' not in backends:
return redirect('social:begin', backends.pop())
return render(
request, 'accounts/register.html', {
'registration_email': 'email' in backends,
'registration_backends': backends - set(['email']),
'title': _('User registration'),
'form': form,
'captcha_form': captcha_form,
})
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
auth_backends = list(load_backends(social_django.utils.BACKENDS).keys())
context["login_backends"] = [x for x in auth_backends if x != "email"]
context["can_reset"] = "email" in auth_backends
context["title"] = _("Sign in")
return context
def post(self, request):
logger = logging.getLogger('netbox.auth.login')
form = LoginForm(request, data=request.POST)
if form.is_valid():
logger.debug("Login form validation was successful")
# If maintenance mode is enabled, assume the database is read-only, and disable updating the user's
# last_login time upon authentication.
if get_config().MAINTENANCE_MODE:
logger.warning("Maintenance mode enabled: disabling update of most recent login time")
user_logged_in.disconnect(update_last_login, dispatch_uid='update_last_login')
# Authenticate user
auth_login(request, form.get_user())
logger.info(f"User {request.user} successfully authenticated")
messages.info(request, "Logged in as {}.".format(request.user))
return self.redirect_to_next(request, logger)
else:
logger.debug("Login form validation failed")
return render(request, self.template_name, {
'form': form,
'auth_backends': load_backends(settings.AUTHENTICATION_BACKENDS),
})
def register(request):
"""Registration form."""
if settings.REGISTRATION_CAPTCHA:
form_class = CaptchaRegistrationForm
else:
form_class = RegistrationForm
if request.method == 'POST':
form = form_class(request.POST)
if form.is_valid() and settings.REGISTRATION_OPEN:
# Ensure we do registration in separate session
# not sent to client
request.session.create()
result = complete(request, 'email')
request.session.save()
request.session = None
return result
else:
form = form_class()
backends = set(load_backends(BACKENDS).keys())
# Redirect if there is only one backend
if len(backends) == 1 and 'email' not in backends:
return redirect('social:begin', backends.pop())
return render(
request, 'accounts/register.html', {
'registration_email': 'email' in backends,
'registration_backends': backends - set(['email']),
'title': _('User registration'),
'form': form,
})
def get_context_data(self, **kwargs):
context = super(WeblateLoginView, self).get_context_data(**kwargs)
auth_backends = list(load_backends(social_django.utils.BACKENDS).keys())
context['login_backends'] = [x for x in auth_backends if x != 'email']
context['can_reset'] = 'email' in auth_backends
context['title'] = _('Login')
return context
def reset_password(request):
"""Password reset handling."""
if 'email' not in load_backends(BACKENDS).keys():
messages.error(
request,
_('Can not reset password, email authentication is disabled!'))
return redirect('login')
if request.method == 'POST':
form = ResetForm(request.POST)
if form.is_valid():
# Force creating new session
request.session.create()
if request.user.is_authenticated:
logout(request)
request.session['password_reset'] = True
return complete(request, 'email')
else:
return redirect('email-sent')
else:
form = ResetForm()
return render(request, 'accounts/reset.html', {
'title': _('Password reset'),
'form': form,
})
def reset_password(request):
"""Password reset handling."""
if 'email' not in load_backends(BACKENDS).keys():
messages.error(
request,
_('Can not reset password, email authentication is disabled!'))
return redirect('login')
if settings.REGISTRATION_CAPTCHA:
form_class = CaptchaResetForm
else:
form_class = ResetForm
if request.method == 'POST':
form = form_class(request.POST)
if form.is_valid():
# Force creating new session
request.session.create()
if request.user.is_authenticated:
logout(request)
users = User.objects.filter(
email__iexact=form.cleaned_data['email'])
if users.exists():
request.session['password_reset'] = True
return complete(request, 'email')
else:
return redirect('email-sent')
else:
form = form_class()
return render(request, 'accounts/reset.html', {
'title': _('Password reset'),
'form': form,
})
def setUp(self):
HTTPretty.enable()
Backend = module_member(self.backend_path)
self.strategy = views.load_strategy()
self.backend = Backend(self.strategy, redirect_uri=self.complete_url)
self.name = self.backend.name.upper().replace('-', '_')
self.complete_url = self.strategy.build_absolute_uri(
self.raw_complete_url.format(self.backend.name))
backends = (self.backend_path, )
load_backends(backends, force_load=True)
user_data_body = json.loads(self.user_data_body)
self.email = '*****@*****.**'
user_data_body['email'] = self.email
self.user_data_body = json.dumps(user_data_body)
self.do_rest_login()
def signin(req):
from astrometry.net import settings
from social_core.backends.utils import load_backends
ctxt = {}
ctxt.update({
'available_backends': load_backends(settings.AUTHENTICATION_BACKENDS)
})
return render_to_response('signin.html', ctxt)
def context(**extra):
return dict(
{
# "plus_id": getattr(settings, "SOCIAL_AUTH_GOOGLE_PLUS_KEY", None),
# "plus_scope": " ".join(GooglePlusAuth.DEFAULT_SCOPE),
"available_backends": load_backends(
settings.AUTHENTICATION_BACKENDS),
},
**extra,
)
def dispatch(self, request, *args, **kwargs):
# Redirect logged in users to profile
if request.user.is_authenticated:
return redirect_profile()
# Redirect if there is only one backend
auth_backends = list(load_backends(BACKENDS).keys())
if len(auth_backends) == 1 and auth_backends[0] != 'email':
return redirect_single(request, auth_backends[0])
return super(WeblateLoginView, self).dispatch(request, *args, **kwargs)
def get(self, request):
form = LoginForm(request)
if request.user.is_authenticated:
logger = logging.getLogger('netbox.auth.login')
return self.redirect_to_next(request, logger)
return render(request, self.template_name, {
'form': form,
'auth_backends': load_backends(settings.AUTHENTICATION_BACKENDS),
})
def test_profile_password_warning(self):
with mock.patch.object(User, "has_usable_password",
return_value=False):
response = self.client.get(reverse("profile"))
self.assertContains(response,
"Please enable the password authentication")
with modify_settings(
AUTHENTICATION_BACKENDS={
"remove": "social_core.backends.email.EmailAuth"
}):
load_backends(settings.AUTHENTICATION_BACKENDS,
force_load=True)
response = self.client.get(reverse("profile"))
self.assertNotContains(
response, "Please enable the password authentication")
self.assertEqual(self.user.has_usable_password(), True)
response = self.client.get(reverse("profile"))
self.assertNotContains(response,
"Please enable the password authentication")
load_backends(settings.AUTHENTICATION_BACKENDS, force_load=True)
def get_context_data(self, **kwargs):
context = super(WeblateLoginView, self).get_context_data(**kwargs)
auth_backends = list(load_backends(BACKENDS).keys())
context['login_backends'] = [x for x in auth_backends if x != 'email']
context['can_reset'] = 'email' in auth_backends
context['title'] = _('Login')
context['demo_users'] = (
('demo', 'demo', _('Standard user')),
('review', 'review', _('User with reviewer permissions')),
)
return context
def dispatch(self, request, *args, **kwargs):
# Redirect signed in users to profile
if request.user.is_authenticated:
return redirect_profile()
# Redirect if there is only one backend
auth_backends = list(load_backends(social_django.utils.BACKENDS).keys())
if len(auth_backends) == 1 and auth_backends[0] != "email":
return redirect_single(request, auth_backends[0])
return super().dispatch(request, *args, **kwargs)
def get_enabled_social_auth_sites_list():
social_auth_backends = load_backends(settings.AUTHENTICATION_BACKENDS)
providers_list = []
for backend_id in social_auth_backends:
backend_name = get_social_auth_backend_name(backend_id)
providers_list.append({
'id': backend_id,
'name': backend_name,
'url': reverse('social:begin', kwargs={'backend': backend_id}),
})
return providers_list
def common_context(authentication_backends, strategy, user=None, plus_id=None, **extra):
"""Common view context"""
context = {
'user': user,
'available_backends': load_backends(authentication_backends),
'associated': {}
}
if user and is_authenticated(user):
context['associated'] = dict((association.provider, association)
for association in associations(user, strategy))
return dict(context, **extra)
def dispatch(self, request, *args, **kwargs):
# Redirect logged in users to profile
if request.user.is_authenticated:
return redirect_profile()
# Redirect if there is only one backend
auth_backends = list(load_backends(social_django.utils.BACKENDS).keys())
if len(auth_backends) == 1 and auth_backends[0] != 'email':
return redirect_single(request, auth_backends[0])
if 'next' in request.GET:
messages.info(request, _('Log in to use Weblate.'))
return super(WeblateLoginView, self).dispatch(request, *args, **kwargs)
def get_context_data(self, **kwargs):
"""Ensure that 'next' gets passed along"""
LOGGER.debug("socialprofile.views.SelectAuthView.get_context_data")
next_url = self.request.GET.get(REDIRECT_FIELD_NAME,
DEFAULT_RETURNTO_PATH)
context = super().get_context_data(**kwargs)
context["next_param"] = REDIRECT_FIELD_NAME
context["next_url"] = next_url
# context["plus_id"] = getattr(settings, "SOCIAL_AUTH_GOOGLE_PLUS_KEY", None)
# context["plus_scope"] = " ".join(GooglePlusAuth.DEFAULT_SCOPE)
context["available_backends"] = load_backends(
settings.AUTHENTICATION_BACKENDS)
return context
def get_enabled_social_auth_sites_list():
social_auth_backends = load_backends(settings.AUTHENTICATION_BACKENDS)
providers_list = []
for backend_id in social_auth_backends:
backend_name = get_social_auth_backend_name(backend_id)
providers_list.append({
"id":
backend_id,
"name":
backend_name,
"url":
reverse("social:begin", kwargs={"backend": backend_id}),
})
return providers_list
def reset_password(request):
"""Password reset handling."""
if request.user.is_authenticated:
redirect_profile()
if 'email' not in load_backends(BACKENDS).keys():
messages.error(
request,
_('Can not reset password, email authentication is disabled!')
)
return redirect('login')
captcha = None
# We're already in the reset phase
if 'perform_reset' in request.session:
return reset_password_set(request)
elif request.method == 'POST':
form = ResetForm(request.POST)
if settings.REGISTRATION_CAPTCHA:
captcha = CaptchaForm(request, form, request.POST)
if (captcha is None or captcha.is_valid()) and form.is_valid():
if form.cleaned_data['email_user']:
rate_limited = notify_account_activity(
form.cleaned_data['email_user'],
request,
'reset-request'
)
if not rate_limited:
request.session['password_reset'] = True
store_userid(request)
return complete(request, 'email')
request.session['registration-email-sent'] = True
return redirect('email-sent')
else:
form = ResetForm()
if settings.REGISTRATION_CAPTCHA:
captcha = CaptchaForm(request)
return render(
request,
'accounts/reset.html',
{
'title': _('Password reset'),
'form': form,
'captcha_form': captcha,
'second_stage': False,
}
)
def similar_backends(context):
backends = load_backends(settings.AUTHENTICATION_BACKENDS)
user = context.get('user')
secondary_users = SecondaryEmail.objects.filter(email=user.email).exclude(
user=user)
similar_users = defaultdict(list)
for secondary in secondary_users:
similar_users[secondary.user].append(
(secondary.provider.provider,
backends.get(secondary.provider.provider)))
similar_users = dict(similar_users)
context['similar_users'] = similar_users
return ''
def common_context(authentication_backends, strategy, user=None, plus_id=None, **extra):
"""Common view context"""
context = {
'user': user,
'available_backends': load_backends(authentication_backends),
'associated': {}
}
if user and is_authenticated(user):
context['associated'] = dict((association.provider, association)
for association in associations(user, strategy))
if plus_id:
context['steam_key'] = plus_id
context['steam_scope'] = ' '.join(SteamOpenId.DEFAULT_SCOPE)
return dict(context, **extra)
