def post(self, request):
"""Log out a user.
The data of the post can (and should) be empty.
"""
logout(request)
return Response({"message": "Logged out."})
def signout(request):
if request.user.is_authenticated():
log_entry = MyLogEntry(user=User.objects.get(pk=request.user.id),
message="logged out.")
log_entry.save()
logout(request)
return HttpResponseRedirect('/')
def delete(self, request):
"""
this model delete will log the user out
"""
# user = self.get_object(request.user)
logout(request)
return Response(status=status.HTTP_204_NO_CONTENT)
def logout_view(request):
"""
Logout a user
"""
logout(request)
# Redirect to a success page.
return HttpResponseRedirect("/")
def logout_view(request):
"""
Logs out the current user.
"""
logout(request)
next = request.GET["next"]
return redirect(next)
def logout(request):
views.logout(request)
next = '/login/'
if 'next' in request.GET:
next = request.GET['next']
return HttpResponseRedirect(next)
def flag_comment(request, comment_id):
"""
Flag a comment.
"""
if not request.user.is_active:
raise PermissionDenied
comment = get_object_or_404(Comment, pk=comment_id)
form = FlagForm(request.POST or None)
if form.is_valid():
if handle_flag_spam(request.user, form.cleaned_data['reason']):
messages.info(request, _(u"Your account has been suspended due to behavior that looks like spam. If this is an error, please contact us using the contact link at the bottom of the page."))
logout(request)
return redirect("/")
ticket, created = Note.objects.get_or_create(
creator=request.user,
text="FLAG from user. \n %s" % form.cleaned_data['reason'],
resolved=None,
important=form.cleaned_data['urgent'],
comment=comment,
)
# Queue up an async process to send notification email in 2 minutes (we
# delay to trap spam floods).
if created:
send_flag_notification_email.apply_async(
args=[ticket.pk], countdown=120)
messages.info(request, _(u"A moderator will review that comment shortly. Thanks for helping us run a tight ship."))
return redirect(comment.document.get_absolute_url())
# redirect to confirmation.
return render(request, "scanning/flag.html", {
'form': form,
})
def index(request, template_name='index.html'):
if request.user.is_authenticated():
if hasattr(request.user, 'retailer'):
return HttpResponseRedirect('/retailer/home/')
elif request.user.is_superuser:
logout(request)
return HttpResponseRedirect('/')
else:
return HttpResponseRedirect('/vault/')
user = request.user
user_updates = user.updates.all()[0:10]
retailer_updates = list()
for retailer in user.subscribed_retailers.all():
retailer_updates.extend(retailer.updates.filter()[0:3])
updates = retailer_updates
updates.extend(user_updates)
updates = sorted(updates, key= lambda update: update.date, reverse=True)
variables = RequestContext(request, {
'updates':updates,
})
else:
variables = RequestContext(request, {})
return render_to_response(template_name, variables)
def baithi_finish(request, pk):
if not request.user.is_authenticated():
return HttpResponseRedirect('/hvhc/tracnghiem/')
baithi = BaiThi.objects.get(pk=pk)
answers = {}
if request.POST:
questions = json.loads(baithi.ds_cauhoi)
for q_id,_ in questions:
try:
answers[q_id] = int(request.POST[q_id])
except:
continue
baithi.save_tralois(answers)
baithi.cham_diem()
baithi.finish()
logout(request)
template = loader.get_template('ketqua.html')
context = RequestContext(request, {
'diem': baithi.diem,
})
return HttpResponse(template.render(context))
def logout(request):
logout(request)
return redirect('index')
#http://stackoverflow.com/questions/32292769/django-user-logout-fails-to-redirect-homepage
def login_user(request):
logout(request)
username = password = ''
# ds_mothi = MonThi.objects.all();
today = datetime.now().date()
ds_cathi = CaThi.objects.filter(ngay_thi=today)
template = loader.get_template('login.html')
context = RequestContext(request, {
'ds_cathi': ds_cathi,
})
if(request.POST):
username = request.POST['username']
password = request.POST['password']
cathi_id = request.POST['cathi']
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
dethi = DeThi.objects.filter(sinh_vien__ma_sv=username, ca_thi=cathi_id)[0]
return HttpResponseRedirect('/quiz/cathi/' + str(dethi.id) + '/')
return HttpResponse(template.render(context))
def logout_user(request):
if request.user.is_authenticated():
views.logout(request ,template_name="index.html")
isAuth = False
username = ""
print isAuth
return render(request, 'index.html', {'user':{'is_authenticated':isAuth, 'username':username}})
def token(request, token):
# We only need the redis manager here, but it's saner to get a whole
# vumi_api and not worry about all the setup magic.
api = vumi_api()
token_data = api.token_manager.get(token)
if not token_data:
raise Http404
user_id = int(token_data['user_id'])
redirect_to = token_data['redirect_to']
system_token = token_data['system_token']
# If we're authorized and we're the same user_id then redirect to
# where we need to be
if not user_id or request.user.id == user_id:
path, _, qs = redirect_to.partition('?')
params = urlparse.parse_qs(qs)
# since the token can be custom we prepend the size of the user_token
# to the token being forwarded so the view handling the `redirect_to`
# can lookup the token and verify the system token.
params.update({'token': '%s-%s%s' % (len(token), token, system_token)})
return redirect('%s?%s' % (path, urlencode(params)))
# If we got here then we need authentication and the user's either not
# logged in or is logged in with a wrong account.
if request.user.is_authenticated():
logout(request)
messages.info(request, 'Wrong account for this token.')
return redirect('%s?%s' % (reverse('auth_login'), urlencode({
'next': reverse('token', kwargs={'token': token}),
})))
def theodoithi_ketthuc(request, pk):
khthi = KHThi.objects.get(pk=pk)
khthi.trang_thai = KHTHI_DATHI
khthi.save()
logout(request)
return HttpResponse('Bạn đã thoát khỏi hệ thống. Bấm <a href=\'/hvhc/tracnghiem/ \'> VÀO ĐÂY </a> để đăng nhập lại')
def finalizar_compra(request):
for prod_id in request.session['prod_ids']:
prod = Produto.objects.get(id=prod_id)
prod.qtd_em_estoque -= 1
prod.save()
logout(request)
return HttpResponseRedirect('/')
def user(request):
"""User page."""
if request.method == 'POST':
if request.POST['opcion']=='Cerrar sesión'.decode('utf-8'):
return auth_views.logout(request,next_page='CicloviaProgram:index')
elif request.POST['opcion']=='Borrar usuario':
DeleteU(request.user.username)
return auth_views.logout(request,next_page='CicloviaProgram:index')
elif request.POST['opcion']=='Actualizar datos':
form = UserChangeFormUniqueEmail(request.POST, instance=User.objects.get(pk=request.user.pk))
if form.is_valid():
userTemp = User.objects.get(pk=request.user.pk)
if form.cleaned_data['email']==userTemp.email or \
len(User.objects.filter(email=form.cleaned_data['email']))is 0:
form.save()
return render(request, 'ciclovia/user.html',
{'form': form,'mensaje': _('User info updated.')})
else:
form.add_error('email',forms.ValidationError(_('email already exists.'),code='used email'))
return render(request, 'ciclovia/user.html', {'form': form})
else:
return render(request, 'ciclovia/user.html', {'form': form})
else:
form = UserChangeFormUniqueEmail(instance=User.objects.get(pk=request.user.pk))
return render(request, 'ciclovia/user.html', {'form': form})
def oa_logout(request):
"""登出账号"""
if request.user.is_authenticated:
logout(request)
messages.success(request, _('You have been signed out.'))
return redirect("kinger_edu_index")
else:
return redirect(request.get_full_path())
def register(request, extra_context=None):
'''register a new user after agreeing to terms and condition'''
try:
base_html_dir = settings.BASE_HTML_DIR
except AttributeError:
base_html_dir = ''
token = {}
if request.method == 'POST':
form = PydginUserCreationForm(request.POST)
if form.is_valid():
new_user = form.save()
new_user.backend = 'django.contrib.auth.backends.ModelBackend'
new_user = authenticate(username=form.cleaned_data['username'].lower(),
password=form.cleaned_data['password1'],
email=form.cleaned_data['email'],
is_terms_agreed=form.cleaned_data['is_terms_agreed'])
# login(request, new_user)
if new_user and new_user.is_authenticated:
'''We have to login once so the last login date is set'''
login(request, new_user)
request_context = RequestContext(request)
request_context.push({"basehtmldir": base_html_dir})
request_context.push({"first_name": new_user.first_name})
request_context.push({"last_name": new_user.last_name})
request_context.push({"user_name": new_user.username})
request_context.push({"user_email": new_user.email})
logout(request)
has_send = send_email_confirmation(request, new_user)
request_context = RequestContext(request)
request_context.push({"basehtmldir": base_html_dir})
if has_send:
request_context.push({"success_registration": True})
return render(request, 'registration/registration_form_complete.html', request_context)
else:
request_context.push({"failure_registration": True})
return render(request, 'registration/registration_form_complete.html', request_context)
else:
print('new_user is not authenticated')
else:
'''not a valid form'''
# print(form.error_messages)
else:
form = PydginUserCreationForm()
token.update(csrf(request))
token['form'] = form
token['basehtmldir'] = base_html_dir
return render(request, 'registration/registration_form.html', token)
def logout(request, next_page=None, template_name='registration/logged_out.html'):
"Logs out the user and displays 'You are logged out' message."
from django.contrib.auth import logout
logout(request)
if next_page is None:
return render_to_response(template_name, {'title': 'Logged out'}, context_instance=RequestContext(request))
else:
# Redirect to this page until the session has been cleared.
return HttpResponseRedirect(next_page or request.path)
def login_adm(request):
if request.user.is_authenticated():
if request.user.is_staff:
return redirect('/adm/blog/post')
else:
stat = 'bukanadmin'
logout(request)
return render(request, 'registration/login.html', {'stat':stat})
else:
return login(request)
def normal_account_logout(request):
if settings.USING_APPENGINE:
# how to log out?
assert "GAE Cannot logout yet"
else:
from django.contrib.auth.views import logout
logout(request)
next_page = djrequest.get_getvar(request, "next", "/")
return HttpResponseRedirect(next_page or request.path)
def get(self, request):
"""
Logs out the current user.
"""
logout(request)
next = request.GET.get('next', None)
if next:
return redirect(next)
else:
return redirect('/')
def custom_logout(request):
redirect_to = "/"
if 'ORG_SETTINGS' in request.session and request.session['ORG_SETTINGS']:
redirect_to = "/"+request.session['ORG_SETTINGS'].login_url+"/"
django_auth_views.logout(request)
print redirect_to
return HttpResponseRedirect(redirect_to)
def boc_tron_de_thi(request, pk):
khthi = KHThi.objects.get(pk=pk)
# get nguoi boc de
nguoi_boc_de = GiaoVien.objects.get(user__pk = request.user.pk)
succ = khthi.boc_va_tron_de(nguoi_boc_de)
logout(request)
if succ:
# return HttpResponseRedirect("/hvhc/tracnghiem/khthi/show/" + str(pk) + "/" )
return HttpResponse("Bốc và trộn đề thành công! Bấm <a href=\"/admin\">VÀO ĐÂY</a> để đăng nhập lại vào hệ thống.")
else:
return HttpResponse(u"Bốc và trộn đề thi KHÔNG thành công! Kiểm tra lại cấu hình sinh đề thi.")
def process_view(self, request, view_func, view_args, view_kwargs):
if (request.user.is_authenticated() and not 'ss' in request.COOKIES):
logout(request)
return HttpResponseRedirect('/')
if (not request.path.startswith("/IVR/") and
request.user.is_authenticated() and
'password_change_time' in request.session and
MHLUser.objects.filter(pk=request.user.pk).only("password_change_time").\
get().password_change_time > request.session['password_change_time']):
logout(request)
return HttpResponseRedirect('/')
def get(self, request):
access_token = request.GET.get('access_token', None)
request_token = request.GET.get('request_token', None)
if not request_token or not access_token:
return self.missing_token_argument()
try:
self.token = Token.objects.select_related('consumer').get(access_token=access_token, request_token=request_token)
except Token.DoesNotExist:
return self.token_not_found()
self.token.delete()
logout(request)
return self.handle_logging_user_out()
def logout(request, template_name="logout.html"):
resDict = {}
# decide another available language.
lang = get_language()
lang_name, lang_link = prepareOtherLang(request, "fake", lang)
resDict["lang_name"] = lang_name
resDict["lang_link"] = lang_link
from django.contrib.auth.views import logout
logout(request)
return render_to_response(template_name, resDict, context_instance=RequestContext(request))
def account_delete(request):
"""
Provides a method for deleting the users account
"""
if request.method == "POST":
form = DeleteAccountForm(request.POST)
if form.is_valid():
user = User.objects.get(pk=request.user.id)
logout(request)
user.delete()
return redirect("/")
else:
form = DeleteAccountForm()
return render(request, "authentication/account_delete.html", {"form": form})
def logout( request, next = None, next_url = None,
template = 'gdjet/account/logout.html',
template_name = None ):
if template_name:
template = template_name
if 'next' in request.GET.keys():
next = request.GET['next']
django_auth.logout(request)
if next_url:
return HttpResponseRedirect( reverse( next_url ) )
if next:
return HttpResponseRedirect(next)
else:
return HttpResponse( loader.get_template ( template ).render(
RequestContext(request, {}) ) )
def change_password(request):
if request.method == 'GET':
return render_to_response("change_password.html", {}, context_instance=RequestContext(request))
if not request.session.has_key("logged_in"):
return home(request)
old_password = request.POST.get('old_pass', None)
password = request.POST.get('pass', None)
conf_password = request.POST.get('conf_pass', None)
if old_password != request.session.get('password'):
return render_to_response("error.html",
{
"error_message": "Incorrect old password!"
},
context_instance=RequestContext(request))
if password == conf_password:
client = get_client(request.session)
res = json.loads(client.EditAccount(request.session.get('username'), password))
if "error_message" in res:
return render_to_response("error.html",
{
"error_message": "Server error while changing password."
},
context_instance=RequestContext(request))
return logout(request, next_page='/')
else:
return render_to_response("error.html",
{
"error_message": "Password and confirmation do not match."
},
context_instance=RequestContext(request))
def connect(request, redirect_field_name=REDIRECT_FIELD_NAME, app_name=None):
""" Connects the Facebook Account to the current logged-in user. """
fb_app = get_app_dict(app_name)
graph = get_graph(request, app_name=app_name)
redirect_to = request.REQUEST.get(redirect_field_name,
fb_app['REDIRECT-URL'])
if request.user.is_authenticated():
try:
me = graph.get_object("me")
except facebook.GraphAPIError as e:
return redirect('fb_login')
# if the user has already a facebook connection, abort and show
# error message
if hasattr(request.user, 'user'):
logger.debug('The logged in user is already connected.')
# check if the django user and FB user match:
if graph.user_id <> request.user.user.id:
logger.debug(
'User %s already connected with Facebook account %s' %
(request.user.get_full_name, request.user.user._name))
auth_views.logout(request, next_page=reverse('fb_app'))
# Otherwise redirect
return redirect(redirect_to)
else:
# The User has no Facebook account attached. Connect him.
try:
# if that facebook user already exists, abort and show error message
fb_user = FacebookUser.objects.get(id=graph.user_id)
except FacebookUser.DoesNotExist:
fb_user = FacebookUser(id=graph.user_id)
fb_user.get_from_facebook(graph=graph, save=True)
else:
if isinstance(fb_user.user, User):
auth_views.logout(request, next_page=reverse('fb_login'))
else:
fb_user.user = request.user
fb_user.save()
finally:
return redirect(redirect_to)
else:
# The user is not logged in
# -> redirect to login page
return redirect('fb_login')
def get(self, request, *args, **kwargs):
context = self.get_context()
defaults = {
'extra_context':
context,
'current_app':
self.admin_site.name,
'template_name':
self.logout_template or 'xadmin/views/logged_out.html',
}
if self.logout_template is not None:
defaults['template_name'] = self.logout_template
self.update_params(defaults)
logout(request, **defaults)
return HttpResponseRedirect(
self.get_param('_redirect') or self.get_admin_url('index'))
def logout(request):
response = auth_views.logout(request,
template_name='registration/logout.html')
# on logout, delete the mirror cookie
response.delete_cookie(settings.MIRROR_COOKIE_NAME,
domain=get_mirror_cookie_domain(request),
path=settings.SESSION_COOKIE_PATH)
return response
def logout(request, **kwargs):
"""Logout view that wraps Django's logout but always redirects.
Django's contrib.auth.views logout method renders a template if the
`next_page` argument is `None`, which we don't want. This view always
returns an HTTP redirect instead.
"""
return auth_views.logout(request, next_page=reverse('home'), **kwargs)
def not_anonymous(request):
"""
Checks if user is logged in and if his account is active.
Logs out inactive users, effectively blocking
them from performing actions.
:param request:
:return:
"""
if request.user.is_authenticated:
if request.user.is_active:
return True
else:
logout(request)
return False
else:
return False
def account_logout(request, next_page):
from django.contrib.auth.views import logout
from social_auth.models import UserSocialAuth
user = request.user
DOMAIN_NAME = request.get_host() #settings.DOMAIN_NAME
try:
instance = UserSocialAuth.objects.filter(provider='facebook').get(
user=user)
access_token = instance.tokens["access_token"]
fb_logout = ('https://www.facebook.com/logout.php?'
'next=http://%s&access_token=%s' %
(DOMAIN_NAME, access_token))
response = logout(request, next_page=fb_logout)
except:
response = logout(request, next_page=next_page)
return response
def weblate_logout(request):
"""Logout handler, just wrapper around standard Django logout."""
messages.info(request, _('Thanks for using Weblate!'))
return auth_views.logout(
request,
next_page=reverse('home'),
)
def auth_logout(request):
"""simple wrapper around django's logout view"""
if request.method == "POST":
from django.contrib.auth.views import logout
return logout(request, next_page="/")
else:
from django.shortcuts import redirect
return redirect("/")
def logout(self, request):
"""
Logs out the user for the given HttpRequest.
This should *not* assume the user is already logged in.
"""
from django.contrib.auth.views import logout
return logout(request)
def middleware(request):
# Code to be executed for each request before
# the view (and later middleware) are called.
response = get_response(request)
user = request.user.is_authenticated()
if request.user.is_staff:
return response
if not user and request.path not in safe_urls:
messages.error(request, 'Login to browse')
return redirect('accounts:login')
if user and not request.user.email_confirmed:
messages.error(request, 'First activate your email')
logout(request)
return response
def customlogout(request):
token = request.session.get('session_user_token', None)
if token:
session_user = UserWebSocketSession.objects.get(token=token)
session_user.session_two_steps = False
session_user.active_websocket = False
session_user.save()
return logout(request)
def logout(request):
response = auth_views.logout(request, next_page='admin_login')
response.delete_cookie(settings.SESSION_COOKIE_NAME,
domain=settings.SESSION_COOKIE_DOMAIN,
path=settings.SESSION_COOKIE_PATH)
request.session.modified = False
return response
def custom_logout(request, **kwargs):
# Current Django 1.6 uses GET to log out
if not request.user.is_authenticated():
return redirect(request.GET.get('next', reverse('spirit:user-login')))
if request.method == 'POST':
return logout(request, **kwargs)
return render(request, 'spirit/user/logout.html')
def dispatch(self, request, *args, **kwargs):
return logout(
request,
template_name=self.template_name,
extra_context={
'cruditor':
self.get_cruditor_context(alternative_title='Logout')
},
)
def logout(self, request, *args, **kwargs):
"""
Calls ``django.contrib.auth.views.logout`` with a custom template and
extra context.
"""
from django.contrib.auth.views import logout
kwargs['template_name'] = self.logout_template
kwargs['extra_context'] = self.default_context()
return logout(request, *args, **kwargs)
def logout(request, next_page):
"""
The logout handler for twitter authentication
"""
logging.debug("Social methods supported are: %s",
social_auth.getSupportedSites())
return django_views.logout(request, next_page, 'social_auth/logout.html')
def user_logout(request):
username = request.user.username
user = User.objects.get(username=username)
try:
v_object = Volttron.objects.get(user=user)
v_object.stop_container()
except ObjectDoesNotExist:
pass
return auth_views.logout(request, next_page='login')
def logout(request):
data = {
'next_page': reverse_lazy('login'),
}
response = auth_views.logout(request, **data)
if issubclass(HttpResponseRedirect, response.__class__):
messages.add_message(request, messages.INFO, "Je bent nu uitgelogd.")
return response
def custom_logout(request, **kwargs):
# Current Django 1.6 uses GET to log out
if not request.user.is_authenticated():
return redirect(request.GET.get('next', reverse('usuario:user-login')))
# end if
if 'cargo' in request.session and 'empresa' in request.session:
del request.session["cargo"]
del request.session["empresa"]
# end if
return logout(request, **kwargs)
def custom_logout(request):
session_id = request.META['HTTP_COOKIE'].split()[1].split('=')[1]
if session_id in settings.FORM_SESSION:
settings.FORM_SESSION.pop(session_id)
# if session_id in SESSION_PAGES:
# SESSION_PAGES.pop(session_id)
return logout(request, next_page='/')
def process_view(self,request,view_func,view_args,view_kargs):
assert hasattr(request,'user')
path=request.path_info.lstrip('/')
print(path)
'''
if not request.user.is_authenticated():
if not any(url.match(path) for url in EXEMPT_URLS):
return redirect(settings.LOGIN_URL)'''
print(('logout').lstrip('/'))
if path==reverse('account:logout').lstrip('/'):
logout(request)
url_is_exempt=any(url.match(path) for url in EXEMPT_URLS)
if request.user.is_authenticated() and url_is_exempt:
return redirect(settings.LOGIN_REDIRECT_URL)
elif request.user.is_authenticated() or url_is_exempt:
return None
else:
return redirect(settings.LOGIN_URL)
def inactivos(request):
ultimo_contrato = Contrato.objects.latest('id')
hoy = date.today()
user = request.user
if ultimo_contrato.fecha_caducidad >= hoy or user.is_superuser:
repositores = Usuario.objects.all()
limite_usuarios = ultimo_contrato.limite_usuarios
porcentaje = int(repositores.count() * 100 / limite_usuarios)
return render(
request, 'inactivos.html', {
'usuarios': repositores,
'porcentaje': porcentaje,
'limite_usuarios': limite_usuarios
})
else:
logout(request)
state = "Tu cuenta ha caducado, por favor ponte en contacto con el administrador."
print(state)
return render(request, 'login.html', {'state': state})
def weblate_logout(request):
'''
Logout handler, just wrapper around standard logout.
'''
messages.info(request, _('Thanks for using Weblate!'))
return auth_views.logout(
request,
next_page=settings.LOGIN_URL,
)
def logout_and_detenderize(request,
next_page=None,
template_name='registration/logged_out.html'):
"""
Logs out the user and removes Tender cookies.
"""
response = logout(request, next_page, template_name)
detenderize_response(response)
return response
def profile_new(request):
if request.method == 'GET':
logout(request)
return render(request, 'profiles/signup.html', {'form': UserCreationForm()})
else:
username = request.POST['username']
if request.POST['password1'] == request.POST['password2']:
password = request.POST['password1']
else:
pass # How to generate those alerts?
newuser = TeamMember.objects.create_user(username, password)
# Should I now check if user has been created?
user = authenticate(username=username, password=password)
if user:
if user.is_active:
login(request, user)
return render(request, 'profiles/profile.html', {'person': user})
else:
pass # Return an 'invalid login' error message.
def listado_marcaciones(request):
ultimo_contrato = Contrato.objects.latest('id')
hoy = date.today()
user = request.user
if ultimo_contrato.fecha_caducidad >= hoy or user.is_superuser:
usuarios = User.objects.filter(is_active=True,
is_superuser=False,
is_staff=False)
limite_usuarios = ultimo_contrato.limite_usuarios
porcentaje = int(usuarios.count() * 100 / limite_usuarios)
marcaciones = Marcacione.objects.all().order_by('-fecha', '-hora')
if 'inicio' in request.GET and 'fin' in request.GET:
f_inicio = request.GET.get('inicio')
f_fin = request.GET.get('fin')
inicio = datetime.strptime(f_inicio, "%d/%m/%Y")
fin = datetime.strptime(f_fin, "%d/%m/%Y")
marcaciones = Marcacione.objects.filter(
fecha__range=[inicio, fin]).order_by('-fecha', '-hora')
filtro_msg = "Filtro de fechas entre el " + str(
f_inicio) + " y el " + str(f_fin)
return render(
request, 'marcaciones.html', {
'marcaciones': marcaciones,
'filtro_msg': filtro_msg,
'inicio': inicio,
'fin': fin,
'usuarios': usuarios,
'porcentaje': porcentaje,
'limite_usuarios': limite_usuarios
})
return render(
request, 'marcaciones.html', {
'marcaciones': marcaciones,
'usuarios': usuarios,
'porcentaje': porcentaje,
'limite_usuarios': limite_usuarios
})
else:
logout(request)
state = "Tu cuenta ha caducado, por favor ponte en contacto con el administrador."
print(state)
return render(request, 'login.html', {'state': state})
def custom_logout(request):
# TODO(jason): once we drop support for password login, we can delete this
# custom logout function in favor of using the OIDC_OP_LOGOUT_URL_METHOD
# setting in the oidc module.
logout_redirect_url = settings.LOGOUT_REDIRECT_URL
if (request.user.is_authenticated() and request.session.get('is_federated')
and logout_redirect_url):
auth_logout(request)
return HttpResponseRedirect(logout_redirect_url)
return logout(request, next_page='/')
def logout_override(request, next_page=None):
"""
Change default logout view to display message after successful logout.
"""
response = logout(request, next_page)
if not isinstance(response, HttpResponseRedirect):
messages.add_message(request, messages.SUCCESS,
_('You have been logged out.'))
return HttpResponseRedirect(reverse('homepage'))
else:
return response
def get(self, request, *args, **kwargs):
context = self.get_context()
defaults = {
'extra_context': context,
'current_app': self.admin_site.name,
}
if self.logout_template is not None:
defaults['template_name'] = self.logout_template
self.update_params(defaults)
return logout(request, **defaults)
def logout(self, request):
"""
Logs out the user for the given HttpRequest.
This should *not* assume the user is already logged in.
"""
from django.contrib.auth.views import logout
defaults = {}
if self.logout_template is not None:
defaults['template_name'] = self.logout_template
return logout(request, **defaults)
