Archived
138 lines
4.6 KiB
Python
138 lines
4.6 KiB
Python
# coding: utf-8
|
|
from django.conf import settings
|
|
from django.contrib.auth.decorators import login_required
|
|
from django.contrib.auth.forms import SetPasswordForm, AuthenticationForm
|
|
from django.contrib.auth import login, logout as auth_logout
|
|
from django.contrib.auth.models import User
|
|
from django.contrib.auth.tokens import default_token_generator
|
|
from django.core.urlresolvers import reverse, reverse_lazy
|
|
from django.http import HttpResponseRedirect, JsonResponse
|
|
from django.http.response import HttpResponseNotFound
|
|
from django.shortcuts import resolve_url, render, get_object_or_404
|
|
from django.template.response import TemplateResponse
|
|
from django.utils.http import urlsafe_base64_decode
|
|
from django.views.decorators.cache import never_cache
|
|
from django.views.decorators.debug import sensitive_post_parameters
|
|
from django.views.generic import FormView
|
|
from django.views.generic import View
|
|
import logging
|
|
|
|
from inside.models import InsideUser
|
|
from neuf_userinfo.forms import NewUserForm
|
|
from neuf_userinfo.tasks import add_new_user
|
|
from neuf_userinfo.utils import add_new_user_sync
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class IndexView(FormView):
|
|
form_class = AuthenticationForm
|
|
success_url = reverse_lazy('my-profile')
|
|
template_name = 'public/index.html'
|
|
|
|
def form_valid(self, form):
|
|
login(self.request, form.get_user())
|
|
return super().form_valid(form)
|
|
|
|
|
|
@login_required
|
|
def profile(request, username=''):
|
|
if username != '' and not request.user.is_superuser:
|
|
# Only allow superusers
|
|
return HttpResponseNotFound()
|
|
|
|
if username != '':
|
|
user = get_object_or_404(User, username=username)
|
|
else:
|
|
user = request.user
|
|
|
|
response = {
|
|
'groups': user.groups.all(),
|
|
'user': user
|
|
}
|
|
return render(request, 'private/profile.html', response)
|
|
|
|
|
|
def logout(request):
|
|
auth_logout(request)
|
|
return render(request, 'registration/logout.html')
|
|
|
|
|
|
# Doesn't need csrf_protect since no-one can guess the URL
|
|
@sensitive_post_parameters()
|
|
@never_cache
|
|
def password_reset_confirm(request, uidb64=None, token=None,
|
|
template_name='registration/password_reset_confirm.html',
|
|
token_generator=default_token_generator,
|
|
set_password_form=SetPasswordForm,
|
|
post_reset_redirect=None,
|
|
current_app=None, extra_context=None):
|
|
"""
|
|
View that checks the hash in a password reset link and presents a
|
|
form for entering a new password.
|
|
|
|
Note: this is the same view as django.contrib.auth.views.password_reset_confirm
|
|
with only minor changes for LDAP-lookup.
|
|
"""
|
|
assert uidb64 is not None and token is not None # checked by URLconf
|
|
|
|
if post_reset_redirect is None:
|
|
post_reset_redirect = reverse('password_reset_complete')
|
|
else:
|
|
post_reset_redirect = resolve_url(post_reset_redirect)
|
|
try:
|
|
uid = urlsafe_base64_decode(uidb64)
|
|
user = InsideUser.objects.get(pk=uid) # Diff vs internal Django view
|
|
except (TypeError, ValueError, OverflowError, InsideUser.DoesNotExist): # Diff vs internal Django view
|
|
user = None
|
|
|
|
if user is not None and token_generator.check_token(user, token):
|
|
validlink = True
|
|
if request.method == 'POST':
|
|
form = set_password_form(user, request.POST)
|
|
if form.is_valid():
|
|
form.save()
|
|
return HttpResponseRedirect(post_reset_redirect)
|
|
else:
|
|
form = set_password_form(None)
|
|
else:
|
|
validlink = False
|
|
form = None
|
|
context = {
|
|
'form': form,
|
|
'validlink': validlink,
|
|
}
|
|
if extra_context is not None:
|
|
context.update(extra_context)
|
|
|
|
return TemplateResponse(request, template_name, context, current_app=current_app)
|
|
|
|
|
|
class AddNewUserView(View):
|
|
|
|
def get(self, request):
|
|
""" Adds a new user to our internal services. See .utils.add_new_user for details. """
|
|
|
|
if not self.validate_api_key(request.GET.get('api_key', '')):
|
|
return JsonResponse({'errors': 'Invalid api_key'})
|
|
|
|
form = NewUserForm(request.GET)
|
|
if not form.is_valid():
|
|
return JsonResponse({'errors': form.errors})
|
|
|
|
user = form.cleaned_data
|
|
logger.debug('Adding user \'{}\'.'.format(user['username']))
|
|
|
|
if settings.INSIDE_USERSYNC_RUN_SYNCHRONOUS:
|
|
add_new_user_sync(user)
|
|
else:
|
|
add_new_user.delay(user) # Async
|
|
|
|
return JsonResponse({'results': 'success'})
|
|
|
|
def validate_api_key(self, api_key):
|
|
if api_key == '' or api_key != settings.INSIDE_USERSYNC_API_KEY:
|
|
return False
|
|
|
|
return True
|