def activate(request, *args, **kwargs):
code = request.GET.get('code')
user_created = request.GET.get('user_created')
invitation = Invitation.objects.get(code=code)
user = invitation.invitee.user
if not user_created:
auth_logout(request)
if not invitation.is_activated() and not user_created:
try:
usermapping = user.usermapping
except UserMapping.DoesNotExist:
redirect = '%s&%s' % (request.build_absolute_uri(),
'user_created=created')
param = urllib.urlencode({'action': 'create', 'redirect': redirect})
return HttpResponseRedirect(
'%s/c/portal/sso?%s' % (settings.PARTNER_BASE, param))
if not request.user.is_authenticated():
return redirect_to_login(request.build_absolute_uri())
if request.user != user:
# TODO: merge user
pass
invitation.activate()
return HttpResponseRedirect('/client/profile.html')
def _should_abort_user(request, should_redirect):
# authorize if user is staff
if request.user.is_staff:
return False
# authorize if user is female and not blocked
not_female = False
blocked = False
if hasattr(request.user, 'profile'):
if request.user.profile.gender == Profile.FEMALE:
if not request.user.profile.blocked:
return False
else:
blocked = True
else:
not_female = True
auth_logout(request)
if should_redirect:
if not_female:
return redirect(resolve_url('female_only'))
elif blocked:
return redirect(resolve_url('blocked'))
return HttpResponseForbidden()
def logout(request, next_page=None,
template_name='registration/logged_out.html',
redirect_field_name=REDIRECT_FIELD_NAME,
current_app=None, extra_context=None):
"""
Logs out the user and displays 'You are logged out' message.
"""
the_user = request.user
auth_logout(request)
user_actions.action_logout(the_user)
redirect_to = request.REQUEST.get(redirect_field_name, '')
if redirect_to:
netloc = urlparse.urlparse(redirect_to)[1]
# Security check -- don't allow redirection to a different host.
if not (netloc and netloc != request.get_host()):
return HttpResponseRedirect(redirect_to)
if next_page is None:
current_site = get_current_site(request)
context = {
'site': current_site,
'site_name': current_site.name,
'title': 'Logged out'
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request, template_name, context,
current_app=current_app)
else:
# Redirect to this page until the session has been cleared.
return HttpResponseRedirect(next_page or request.path)
def logout(request):
"""
Log the user out.
"""
auth_logout(request)
info(request, _("Successfully logged out"))
return redirect(next_url(request) or get_script_prefix())
def logout(request, next_page=None,
template_name='registration/logged_out.html',
redirect_field_name=REDIRECT_FIELD_NAME,
current_app=None, extra_context=None):
"""
Logs out the user and displays 'You are logged out' message.
"""
auth_logout(request)
if redirect_field_name in request.REQUEST:
next_page = request.REQUEST[redirect_field_name]
# Security check -- don't allow redirection to a different host.
if not is_safe_url(url=next_page, host=request.get_host()):
next_page = request.path
if next_page:
# Redirect to this page until the session has been cleared.
return HttpResponseRedirect(next_page)
current_site = get_current_site(request)
context = {
'site': current_site,
'site_name': current_site.name,
'title': _('Logged out')
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request, template_name, context,
current_app=current_app)
def logout(request):
"""
Log the user out.
"""
auth_logout(request)
info(request, _("Successfully logged out"))
return redirect(request.GET.get("next", "/"))
def logout(request):
"""
Log the user out.
"""
auth_logout(request)
info(request, _("Successfully logged out"), fail_silently=True)
return HttpResponseRedirect(request.GET.get("next", "/"))
def logout(request):
# It's safer to handle logout requests as POST
if request.method == 'POST':
auth_logout(request)
return redirect('uploads.views.index')
else:
raise Http404
def verify(request):
try:
auth = authenticate(request, settings.SAML_1['URL'])
except SamlException as e:
ctx = {'e': e}
return render_to_response('registration/saml_error.html', ctx)
if UserProfile.objects.filter(verified_ssn=auth['ssn']).count() > 0:
taken_user = UserProfile.objects.select_related('user').get(verified_ssn=auth['ssn']).user
ctx = {
'auth': auth,
'taken_user': taken_user,
}
auth_logout(request)
return render_to_response('registration/verification_duplicate.html', ctx)
profile = request.user.userprofile # It shall exist at this point
profile.verified_ssn = auth['ssn']
profile.verified_name = auth['name'].encode('utf8')
profile.verified_token = request.GET['token']
profile.verified_timing = datetime.now()
profile.save()
if hasattr(settings, 'ICEPIRATE'): # Is IcePirate support enabled?
configure_external_member_db(request.user, create_if_missing=True)
return HttpResponseRedirect('/')
def delete_account(request):
context = {}
if request.method == 'POST':
confirma = request.POST.get('borrar', False)
if confirma:
try:
token = str(uuid4())
user = request.user
cache.set(token, user.username,
timeout=settings.USER_DELETION_TTL)
emails = ['registration/default/delete_email_subject.txt',
'registration/default/delete_email_subject.txt']
subject = render_to_string(select_template(emails).name,
{'site': settings.SITE_URL})
delete_url = 'accounts:registration-confirm-deletion'
mail_vars = {'site': settings.SITE_URL,
'path': reverse(delete_url, args=[token])}
emails = ['registration/default/delete_email.html',
'registration/default/delete_email.html']
html_content = render_to_string(select_template(emails).name,
mail_vars)
msg = EmailMessage(subject.strip("\n"), html_content,
settings.DEFAULT_FROM_EMAIL, [user.email])
# Main content is now text/html
msg.content_subtype = "html"
msg.send()
mensaje = _(u'Te enviamos instrucciones para completar el cierre de tu cuenta.')
messages.success(request, mensaje)
auth_logout(request)
except Exception as e:
logger.error("Obtained error {e}".format(e=e.message))
return render(request, 'accounts/delete_account_success.html',
context)
return render(request, 'accounts/delete_account.html', context)
def confirm_deletion(request, token):
key = cache.get(token, None)
if key:
cache.delete(token)
try:
user = User.objects.get(username=key)
back_user = serializers.serialize('json', [user])
ex_profile = ExtendedProfile.objects.filter(user=user)
back_profile = serializers.serialize('json', ex_profile)
backup_info = {'user': back_user, 'extended_profile': back_profile}
deleted_user = DeletedUser()
deleted_user.identifier = user.email
deleted_user.user_information = backup_info
deleted_user.save()
user.delete()
messages.success(request, _(u'Tu cuenta ha sido borrada.'))
auth_logout(request)
except Exception as e:
logger.error("Error {e} en borrado de usuario".format(e=e))
msg = _(u'Tu cuenta no ha sido borrada. Por favor intentar nuevamente')
messages.error(request, msg)
return redirect('accounts:profile')
else:
msg = _(u'Tu cuenta no ha sido borrada. Por favor intentar nuevamente')
messages.error(request, msg)
return redirect('accounts:profile')
def password(request):
"""
修改用户密码
"""
current_page = 'profile-password'
if request.method == 'POST':
raw_password = request.POST.get('raw_password','')
new_password1 = request.POST.get('new_password1','')
new_password2 = request.POST.get('new_password2','')
if not request.user.check_password(raw_password):
messages.error(request,'原始密码错误！')
elif len(new_password1)<6 or len(new_password1)>30:
messages.error(request,'新密码的长度不符合要求！')
elif new_password1 <> new_password2:
messages.error(request,'两次新密码输入不一致！')
else:
try:
request.user.set_password(str(new_password2))
request.user.save()
except Exception,e:
raise e
auth_logout(request)
messages.success(request,'密码修改成功！请使用新密码重新登录一次。')
return HttpResponseRedirect('/accounts/login/?next=/home/')
def logout(request):
auth_logout(request)
redirect_to = request.POST.get(REDIRECT_FIELD_NAME,
request.GET.get(REDIRECT_FIELD_NAME, ''))
return HttpResponseRedirect(redirect_to or reverse('accounts:login'))
def logout(request):
redirect = request.GET.get("redirect", request.POST.get("redirect", kwargs.get("redirect", "")))
if not is_safe_url(url=redirect, host=request.get_host()):
redirect = reverse("home")
auth_logout(request)
return HttpResponseRedirect(redirect)
def dispatch(self, request, *args, **kwargs):
auth_logout(request)
next_page = self.get_next_page()
if next_page:
# Redirect to this page until the session has been cleared.
return HttpResponseRedirect(next_page)
return super(LogoutView, self).dispatch(request, *args, **kwargs)
def logout_view(request):
from django.contrib.auth import logout as auth_logout
cashdesk = get_cashdesk(request)
if cashdesk:
sessions = CashdeskSession.objects.filter(cashdesk=cashdesk, cashier=request.user, valid_from__lte=datetime.datetime.now(), cashier_has_ended=False)
try:
session = sessions[0]
if request.GET.get('type') == 'session_end':
# we have an active session -- end it and open the cash drawer
open_drawer(cashdesk.receipt_printer_name)
session.is_logged_in = False
# set the session end time to NOW
session.valid_until = datetime.datetime.now()
session.cashier_has_ended = True
session.save()
cashdesk.active_session = None
cashdesk.save()
else:
session.is_logged_in = False
session.save()
except:
pass
auth_logout(request)
return HttpResponseRedirect(reverse("dashboard"))
def change_email(request, token):
try:
email_change_request = EmailChangeRequest.objects.get(
token=token, valid_until__gte=now())
# TODO: cronjob (celery task) to delete stale tokens
except EmailChangeRequest.DoesNotExist:
return TemplateResponse(request, 'registration/invalid_token.html')
# if another user is logged in, we need to log him out, to allow the email
# owner confirm his identity
if (request.user.is_authenticated() and
request.user != email_change_request.user):
auth_logout(request)
if not request.user.is_authenticated():
query = urlencode({
'next': request.get_full_path(),
'email': email_change_request.user.email})
login_url = utils.url(path=settings.LOGIN_URL, query=query)
return redirect(login_url)
request.user.email = email_change_request.email
request.user.save()
email_change_request.delete()
messages.success(request, _('Your email has been successfully changed'))
return redirect(settings.LOGIN_REDIRECT_URL)
def get(self, request, *args, **kwargs):
if defs.USERWARE_SWTICHED_USER_KEY in request.session:
del request.session[defs.USERWARE_SWTICHED_USER_KEY]
if request.user.is_authenticated():
auth_logout(request)
messages.add_message(self.request, messages.SUCCESS, _('You are now logged out.'))
return HttpResponseRedirect(defs.LOGOUT_REDIRECT_URL)
def logout(request):
try:
del request.session['wechat_id']
except:
pass
auth_logout(request)
return redirect(reverse("home", kwargs={}))
def logout(request, redirect_url=None):
auth_logout(request)
url = redirect_url or getattr(settings, 'LOGOUT_REDIRECT_URL', '/')
return HttpResponseRedirect(url)
def logout(request, species_wid=None): auth_logout(request) return render_queryset_to_response( species_wid = species_wid, request = request, templateFile = 'public/logout.html', )
def choose_collection(request):
redirect_to = request.REQUEST.get('next', '')
redirect_resp = HttpResponseRedirect(
redirect_to if is_safe_url(url=redirect_to, host=request.get_host())
else settings.LOGIN_REDIRECT_URL
)
available_collections = users_collections(connection.cursor(), request.specify_user.id)
if len(available_collections) < 1:
auth_logout(request)
return TemplateResponse(request, 'choose_collection.html', context={'next': redirect_to})
if len(available_collections) == 1:
set_collection_cookie(redirect_resp, available_collections[0][0])
return redirect_resp
class Form(forms.Form):
collection = CollectionChoiceField(
choices=available_collections,
initial=request.COOKIES.get('collection', None))
if request.method == 'POST':
form = Form(data=request.POST)
if form.is_valid():
set_collection_cookie(redirect_resp, form.cleaned_data['collection'])
return redirect_resp
else:
form = Form()
context = {'form': form, 'next': redirect_to}
return TemplateResponse(request, 'choose_collection.html', context)
def logout(request, redirect_to=None):
auth_logout(request)
if redirect_to is None:
return redirect('login')
else:
return redirect(redirect_to)
def logout(request, next_page=None):
"""Redirects to CAS logout page"""
# try to find the ticket matching current session for logout signal
try:
st = SessionTicket.objects.get(session_key=request.session.session_key)
ticket = st.ticket
except SessionTicket.DoesNotExist:
ticket = None
# send logout signal
cas_user_logout.send(
sender="manual",
user=request.user,
session=request.session,
ticket=ticket,
)
auth_logout(request)
# clean current session ProxyGrantingTicket and SessionTicket
ProxyGrantingTicket.objects.filter(session_key=request.session.session_key).delete()
SessionTicket.objects.filter(session_key=request.session.session_key).delete()
next_page = next_page or get_redirect_url(request)
if settings.CAS_LOGOUT_COMPLETELY:
protocol = get_protocol(request)
host = request.get_host()
redirect_url = urllib_parse.urlunparse(
(protocol, host, next_page, '', '', ''),
)
client = get_cas_client()
return HttpResponseRedirect(client.get_logout_url(redirect_url))
else:
# This is in most cases pointless if not CAS_RENEW is set. The user will
# simply be logged in again on next request requiring authorization.
return HttpResponseRedirect(next_page)
def logout(request, *args, **kwargs):
auth_logout(request)
messages.success(request,
"You have successfully logged out.")
if 'next' in kwargs:
return redirect(kwargs['next_page'])
return bounce(request)
def logout(request):
'''
logout current user
'''
if request.user.is_authenticated():
auth_logout(request)
return redirect("/")
def logout(request, next_page=None,
template_name='registration/logged_out.html',
redirect_field_name=REDIRECT_FIELD_NAME,
current_app=None, extra_context=None):
"""
Logs out the user and displays 'You are logged out' message.
A copy/paste of django.contrib.auth.views.logout, except with
a different is_safe_url() check.
"""
# XXX TODO: Replace this function with something that's
# more flexible - class based auth?
auth_logout(request)
if redirect_field_name in request.REQUEST:
next_page = request.REQUEST[redirect_field_name]
# Security check -- don't allow redirection to a different host.
if not is_safe_url(next_page):
next_page = '/'
if next_page:
# Redirect to this page until the session has been cleared.
return HttpResponseRedirect(next_page)
current_site = get_current_site(request)
context = {
'site': current_site,
'site_name': current_site.name,
'title': _('Logged out')
}
if extra_context is not None:
context.update(extra_context)
return TemplateResponse(request, template_name, context,
current_app=current_app)
def api_login(request):
if request.method == 'PUT':
data = simplejson.load(request)
if any(data[key] is None for key in 'username password collection'.split()):
auth_logout(request)
return HttpResponse('', status=204)
user = authenticate(username=data['username'],
password=data['password'])
if user is None:
return HttpResponseForbidden()
auth_login(request, user)
try:
collection = Collection.objects.get(id=data['collection'])
except Collection.DoesNotExist:
return HttpResponseBadRequest('collection %s does not exist' % data['collection'])
response = HttpResponse('', status=204)
set_collection_cookie(response, collection.id)
return response
return HttpResponse(simplejson.dumps(dict(
collections={c.collectionname: c.id for c in Collection.objects.all()},
username=None,
password=None,
collection=None)), content_type='application/json')
def logout(request):
if request.user.is_authenticated:
print(request.user)
auth_logout(request)
print("after")
print(request.user)
return HttpResponseRedirect("/polls/login")
def third_user_login(request):
"""
The method is third user login
@param request: third_key, third_type
@return:
"""
if request.method == 'GET':
return response_fail_to_mobile(500, REQUEST_METHOD_ERROR)
try:
username = request.POST['third_key']
password = request.POST['third_type']
user = authenticate(username=username, password=password, type=3)
auth_login(request, user)
logic = UserProfileLogic.get_user_profile_by_user_id(user_id=request.user.id)
last_login = datetime_convert_current_timezone(logic.last_login_time)
if last_login is not None:
last_login = datetime_to_string(last_login)
if logic.user_nick is None:
user_nick = ''
else:
user_nick = logic.user_nick
rec = dict()
rec['session_id'] = request.session._session_key
rec['user_id'] = request.user.id
rec['user_name'] = user_nick
rec['last_login'] = last_login
UserProfileLogic.update_last_login_time(request.user.id)
return response_success_to_mobile(rec)
except Exception as e:
error(e)
auth_logout(request)
return response_fail_to_mobile(500, 'Third part account login fail!')
def logout(request):
"""
Log the user out of the current session, then redirect to login page.
"""
auth_logout(request)
return redirect('control:auth.login')
def post(self, request, *args, **kwargs):
auth_logout(request)
return HttpResponseRedirect(request.get_full_path())
def logout(request):
auth_logout(request)
return redirect('articles:index')
def logout(request):
auth_logout(request)
messages.success(request, "Logged out!")
return redirect('login')
def logout(request):
auth_logout(request)
return redirect('todos:index')
def logout_view(request):
auth_logout(request)
url2 = reverse_url("index")
return HttpResponseRedirect(url2)
def logout(request):
auth_logout(request)
return redirect('/')
def logout(request):
logger.info("%s logging out", request.user)
auth_logout(request)
return HttpResponseRedirect(reverse('landing_page'))
def logout(request):
'''注销视图'''
auth_logout(request)
return HttpResponseRedirect(reverse('index'))
def logout(request):
auth_logout(request)
return redirect("movie:index")
def logout(request):
"""
Logout view for the API consumer
"""
auth_logout(request)
return JsonResponse({'success': 'logout'})
def logout(request):
auth_logout(request)
return redirect("login")
def logout(request):
auth_logout(request)
return HttpResponseRedirect(reverse('question:index'))
def logout(request):
auth_logout(request)
return redirect('movies:list')
def logout(request): # Session을 Delete하는 방식으로 로그아웃 기능 구현
if request.method == 'POST':
auth_logout(request)
return redirect('boards:index')
else:
return redirect('boards:index')
def logout(request):
auth_logout(request)
return redirect('boards:index')
def logout(request):
if request.user.is_authenticated:
auth_logout(request)
return HttpResponseRedirect(request.GET.get('next'))
def logout(request):
auth_logout(request)
return HttpResponse(
'<script>window.alert("Ok!");location.href="/account/login"</script>')
def get(self, request):
if is_user_logged_in(request):
auth_logout(request)
messages.info(request, "You have logged out.")
return redirect("home")
def logout(request):
createLogEvent(request.user.username, "view: logout", 4, "User logged out")
auth_logout(request)
message = "Successfully logged out!"
messages.add_message(request, messages.INFO, message)
return HttpResponseRedirect("/")
def logout(request):
auth_logout(request)
return redirect('community:index')
def logout(request):
auth_logout(request)
return redirect('accounts:login')
def logout(request):
auth_logout(request)
request.session.set_expiry(0)
next_url = request.META.get('HTTP_REFERER', reverse('web_selection'))
return HttpResponseRedirect(next_url)
def handle_logout(request):
"""
Log out.
"""
auth_logout(request)
def get(self, request, *args, **kwargs):
auth_logout(request)
return super(LogoutView, self).get(request, *args, **kwargs)
def get_object(self):
logged_user = get_object_or_404(UserProfile, user=self.request.user)
if logged_user:
auth_logout(self.request)
return logged_user
def logout(request):
auth_logout(request)
return render(request, 'users/login.html', {'message': 'Logged out.'})
def logout(request):
auth_logout(request)
return HttpResponseRedirect('/')
def logout(request):
form_login = LoginForm()
auth_logout(request)
return HttpResponseRedirect("/")
def logout(req):
if not req.user.is_authenticated:
return redirect('index')
auth_logout(req)
return redirect('index')