def logout_user(request):
logout(request)
form = UserForm(request.POST or None)
context = {
"form": form,
}
return render(request, 'cool/index.html', context)
def register(request):
form_data = request.POST.copy()
form = RegistrationForm(form_data)
errors = form.errors
print request.POST
print form.errors
if errors:
return render_to_response('login.html', {'form': form})
# logout the existing user
if (isinstance (request.user, AnonymousUser)):
u = None
else:
u = request.user
logout(request)
email = request.POST['register_email']
password = request.POST['register_password']
try:
u = User(username=email)
u.set_password(password)
u.email = email
u.save()
except:
return render_to_response('login.html', {'form': form})
response = render_to_response('login.html', {'registration_status': "Registered successfully! Now you can login with your credentials!" })
return response
def GetContext(self, **kwargs):
uid=int(kwargs.get("uid",0))
auth.logout(self.request)
self.returnUrl="/"
return locals()
def process_request(request):
if not request.user.is_authenticated():
return HttpResponseRedirect('homepage/login/')
else:
logout(request)
return templater.render_to_response(request, 'logout.html')
def post(self, request, **kwargs):
auth.logout(request)
backend = request.POST.get('backend')
return redirect("{}?next={}".format(
reverse('social:begin', kwargs={
'backend': request.POST.get('backend'), }),
self.relogin_data['next_url']))
def handleLoginService(request):
if request.user.is_authenticated():
for checkuser in MyUser.objects.all():
if checkuser.id==request.user.id:
return render(request,'invalidloginservice.html')
return redirect('mainservice')
f=LoginFormService(request.POST)
next_url=request.GET.get('next')
if f.is_valid():
user=f.get_user()
login(request,user)
for checkuser in MyUser.objects.all():
if checkuser.id==user.id:
logout(request)
return render(request,'invalidloginservicelogout.html')
if not next_url:
return redirect('mainservice')
else :
return redirect(next_url)
else:
loginform=f
signupform=SignupFormService(initial={'phone':'+91'})
data={'signupform':signupform,'loginform':loginform,'next':next_url}
return render(request,'loginservice.html',data)
def oauth_logout(request):
# Log a user out using Django's logout function and redirect them back to the homepage.
logout(request)
# request.session.flush()
# request.session.clear()
# request.session['request_token'] = ''
# del request.session['request_token']
# for sesskey in request.session.keys():
# del request.session[sesskey]
# del request.session
# request.session = ''
# # request.session['HTTP_COOKIE']
# # request.session['TERM_SESSION_ID']
# request.user = AnonymousUser()
# user = AnonymousUser()
# access_token = ''
# token = ''
# client = ''
# content = ''
# settings.LINKEDIN_TOKEN = ''
# request.META['HTTP_COOKIE'] = ''
# request.COOKIES['sessionid'] = ''
# assert False
return HttpResponseRedirect('/introkick/')
def auth(request):
auth_attempt_success = None
# POST request is taken to mean user is logging in
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None and user.is_active:
login(request, user)
user.password = ''
auth_attempt_success = True
else:
auth_attempt_success = False
next = request.GET.get('next', reverse('home'))
if auth_attempt_success:
return redirect(next)
else:
if request.GET.get('logout', None) is not None:
logout(request)
# need to redirect to 'auth' so that the user is set to anonymous via the middleware
return redirect('auth')
else:
return render_to_response('login.htm', {
'main_script': 'login',
'auth_failed': (auth_attempt_success is not None),
'next': next
},
context_instance=RequestContext(request))
def register(request):
if request.method == 'GET':
form = RegisterForm()
return render(request, 'register.html', {"form": form})
elif request.method == 'POST':
form = RegisterForm(request.POST)
if form.is_valid():
name = form.cleaned_data['username']
pword = form.cleaned_data['password']
email = form.cleaned_data['email']
# If username doesn't already exist
if not User.objects.filter(username__exact=name).count():
# if email doesn't already exist
if not User.objects.filter(email__exact=email).count():
User.objects.create_user(name, email, pword)
else:
return render(request, 'register.html', {"form": form, "error_message": "Email %s is already registered." % email})
else:
return render(request, 'register.html', {"form": form, "error_message": "User %s already exists." % name})
# If a user is already logged in, log them out
if request.user.is_authenticated():
logout(request)
new_user = authenticate(username=name, password=pword)
login(request, new_user)
return HttpResponseRedirect(reverse('home'))
else:
return render(request, 'register.html', {"form": form})
def logoutuser(request):
user = request.user
if user.is_authenticated():
logout(request)
return render(request,htmlPageMap['index'])
else:
return render(request,htmlPageMap['index'])
def inicio(request):
globales = variables_globales(request)
mensaje= False
formulario = LoginForm()
if not request.user.is_anonymous():
if globales['HOY'] > EXPIRA:
mensaje="Periodo de sistema expirado"
logout(request)
else:
if request.user.perfil == 'Maestro':
return HttpResponseRedirect(reverse('index'))
else:
return HttpResponseRedirect(reverse('index_alumno'))
if request.method == "POST":
formulario = LoginForm(request.POST)
if formulario.is_valid():
usuario = formulario.cleaned_data["usuario"]
password = formulario.cleaned_data["password"]
acceso = authenticate(username=str(usuario), password=str(password))
if acceso is not None:
if acceso.is_active:
login(request, acceso)
return HttpResponseRedirect(reverse('inicio'))
else:
mensaje="Tu usuario esta desactivado"
else:
mensaje="Usuario o contraseña incorrecta"
else:
mensaje="Usuario o contraseña incorrecta"
return render(request, 'login.html',locals())
def logout(request):
"""Destroy user session."""
mark_registered = request.user.is_authenticated()
auth.logout(request)
if mark_registered:
request.session['mark_registered'] = True
return http.HttpResponseRedirect(reverse('splash'))
def process_request(self, request):
# AuthenticationMiddleware is required so that request.user exists.
if not hasattr(request, 'user'):
raise ImproperlyConfigured(
"The Django remote user auth middleware requires the"
" authentication middleware to be installed. Edit your"
" MIDDLEWARE_CLASSES setting to insert"
" 'django.contrib.auth.middleware.AuthenticationMiddleware'"
" before the XoopsAuthMiddleware class.")
if request.user.is_authenticated():
if request.user.is_staff or request.user.is_superuser:
if FOLLOW_ONLY_USERS:
return
elif not FOLLOW:
return
try:
sess_id = request.COOKIES[self.COOKIE_KEY]
user = create_user_from(sess_id=sess_id)
if user:
user.backend = 'django.contrib.auth.backends.ModelBackend'
auth.login(request, user)
return
except:
logger.debug(traceback.format_exc())
pass
if FOLLOW:
auth.logout(request)
def common_logout(request):
from django.contrib.auth import logout
logout(request)
return HttpResponseRedirect("/home")
def user_logout(request):
"""
Logs the user out and renders the home page with a message informing them that
they've just logged out.
"""
logout(request)
return render(request, 'home.html', {'just_logged_out': True})
def login_as(request):
user = None
user_pk = request.GET.get('user_pk', None)
if user_pk:
try:
user = User.objects.get(pk=user_pk)
except User.DoesNotExist:
pass
username = request.GET.get('username', None)
if username:
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
pass
if user:
user.backend = 'django.contrib.auth.backends.ModelBackend'
login(request, user)
else:
logout(request)
redirect_to = request.GET.get('next')
if not redirect_to or not is_safe_url(redirect_to):
return redirect('/workflow/')
else:
return HttpResponseRedirect(redirect_to)
def login_user(request):
context = RequestContext(request)
logout(request) # Logout
if request.POST:
username = request.POST.get('username', '')
if not username:
raise Http404('Please enter a Username.')
user = authenticate(username=username, password='')
if user is not None:
login(request, user)
# Create Chat Rooms
ChatRoom.create_rooms(user)
next = request.POST.get('next', '')
print 'next....... : ', next
if next:
return HttpResponseRedirect(next)
return HttpResponseRedirect('/available_chats/')
else:
raise Http404('Username does not exist. {0}'.format(username))
context = {
'next': request.GET.get('next', '')
}
return render_to_response('login.html', context, RequestContext(request))
def logout(self, request, **kwargs):
self.method_check(request, allowed=['get'])
if request.user and request.user.is_authenticated():
logout(request)
return self.create_response(request, { 'success': True })
else:
return self.create_response(request, { 'success': False }, HttpUnauthorized)
def handle_unauthorized(
request, message, redirect, ignore, escalate, handled, force_silence, force_log, log_method, log_entry, log_level
):
if ignore:
return NotAuthorized
if not force_silence and not handled:
log_method(error_color("Unauthorized: %s" % log_entry))
if not handled:
if message:
message = _("Unauthorized: %s") % message
# We get some pretty useless error messages back from
# some clients, so let's define our own fallback.
fallback = _("Unauthorized. Please try logging in again.")
messages.error(request, message or fallback)
# Escalation means logging the user out and raising NotAuthorized
# so the middleware will redirect them appropriately.
if escalate:
# Prevents creation of circular import. django.contrib.auth
# requires openstack_dashboard.settings to be loaded (by trying to
# access settings.CACHES in in django.core.caches) while
# openstack_dashboard.settings requires django.contrib.auth to be
# loaded while importing openstack_auth.utils
from django.contrib.auth import logout # noqa
logout(request)
raise NotAuthorized
# Otherwise continue and present our "unauthorized" error message.
return NotAuthorized
def account_request(request, type):
if type == 'logout':
logout(request)
return HttpResponseRedirect(reverse('content:login', args=(0, 2,)))
username = request.POST['username']
password = request.POST['password']
if type == 'login':
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
if('content/login' in request.META.get('HTTP_REFERER')):
return HttpResponseRedirect("/content")
else:
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
return HttpResponseRedirect(reverse('content:login', args=(1, 0,)))
elif type == 'register':
user = User.objects.filter(username=username);
if len(user) > 0:
return HttpResponseRedirect(reverse('content:register', args=(1,)))
elif password != request.POST['confirm']:
return HttpResponseRedirect(reverse('content:register', args=(2,)))
else:
user = User.objects.create_user(username=username, password=password)
user.save()
return HttpResponseRedirect(reverse('content:login', args=(0, 1,)))
def auth_logout(request):
"""
Log out a user
"""
logout(request)
return HttpResponseRedirect( reverse('startpage') )
def logout_user(request):
logout(request)
form = UserForm(request.POST or None)
context = {
"form": form,
}
return render(request, 'betting/login.html', context)
def post(self, *args, **kwargs):
self.request.user.is_active = False
self.request.user.save()
auth.logout(self.request)
add_message(self.request, 'account_delete',
expunge_hours=settings.ACCOUNT_DELETION_EXPUNGE_HOURS)
return redirect(self.get_success_url())
def register(request):
"""Handles the logic for registering a user into the system."""
if request.method != 'POST':
form = UserCreationForm()
return render_to_response('register.html',
{'form': form}, RequestContext(request))
form = UserCreationForm(data=request.POST)
if not form.is_valid():
return render_to_response('register.html',
{'form': form}, RequestContext(request))
auth.logout(request)
user = form.save(commit=False)
user.email = user.username
user.is_active = True
user.save()
authed_user = auth.authenticate(
username=user.username,
password=form.cleaned_data['password1']
)
auth.login(request, authed_user)
return redirect('paste')
def post(self, request):
"""Log the user out."""
auth.logout(request)
return JSONResponse({
'redirect': self.redirect_url
})
def delete(self, request):
"""Logout"""
logout(request)
return utils.json_response({
'authenticated': False,
'username': ""
})
def perform_logout(request):
"""
Logout user
"""
logout(request)
return redirect(reverse(settings.LANDING_VIEW))
def profile_create(request):
try:
request.user.get_profile()
return http.HttpResponseRedirect(reverse('dashboard_index'))
except UserProfile.DoesNotExist:
pass
form = forms.CreateProfileForm(request.POST)
if form.is_valid():
profile = form.save(commit=False)
profile.user = request.user
profile.user.email = profile.email
profile.confirmation_code = profile.generate_confirmation_code()
profile.save()
profile.user.save()
path = reverse('users_confirm_registration', kwargs={
'username': profile.username,
'token': profile.confirmation_code,
})
url = request.build_absolute_uri(path)
profile.email_confirmation_code(url)
auth.logout(request)
msg = _('Thanks! We have sent an email to {0} with '
'instructions for completing your '
'registration.').format(profile.email)
messages.info(request, msg)
return http.HttpResponseRedirect(reverse('dashboard_index'))
else:
messages.error(request, _('There are errors in this form. Please '
'correct them and resubmit.'))
return render_to_response('dashboard/setup_profile.html', {
'form': form,
}, context_instance=RequestContext(request))
def logout_handler(request):
"""
Handle a logout request
"""
logout(request)
return HttpResponseRedirect('/welcome')
def logout(self, request):
"Logs out user and redirects them to Nexus home"
from django.contrib.auth import logout
logout(request)
return HttpResponseRedirect(reverse('nexus:index', current_app=self.name))
def destroy(self, request, pk=None):
logout(request)
return Response([])
def logout_view(request):
logout(request)
return redirect('/login')
def logout(request):
auth.logout(request)
return HttpResponseRedirect('/team')
def logoutpage(request):
logout(request)
messages.success(request, f'You have been logged out!')
return redirect('home')
def logout_view(request):
"""Logging off the user"""
logout(request)
return redirect("homepage")
def logout_view(request):
# Logout and redirect to homepage
logout(request)
return redirect('singkat:home')
def logout_view(request):
logout(request)
JsonResponse({'Response': True})
def user_logout(request):
logout(request)
return redirect('login:login')
def user_logout(request):
# Log out the user.
logout(request)
# Return to homepage.
return HttpResponseRedirect(reverse('index'))
def logout_user(request):
logout(request)
return redirect('/')
def logout(request):
auth.logout(request)
return {}
def logout_out(request):
logout(request)
return HttpResponseRedirect(reverse('storeapp:login'))
def logout(request):
auth.logout(request)
return HttpResponseRedirect(reverse("main"))
def user_logout(request):
''' функция выхода пользователя из системы'''
logout(request)
return redirect(request.META.get('HTTP_REFERER'))
def logout(request):
user = request.user
auth.logout(request)
return HttpResponse('<h1> %s had logout!</h1>' % user)
def logout_view(request):
""" Logs user out of account """
logout(request)
return redirect('home')
def user_logout(request):
logout(request)
return HttpResponseRedirect('/')
def logout_user(request, response):
logout(request)
response.delete_cookie(API_TOKEN_COOKIE,
domain=settings.SESSION_COOKIE_DOMAIN)
def signout(request):
if request.method == 'POST':
auth.logout(request)
return redirect('首页')
def logout_view(request):
"""Log the user out."""
logout(request)
return HttpResponseRedirect(reverse('learning_logs:index'))
def userlogout(request):
if request.method == 'POST':
logout(request)
messages.success(request, "you are now logged out")
return redirect('index')
def user_logout(request):
logout(request)
return redirect('/app/user_login/')
def logout_view(request):
logout(request)
return HttpResponseRedirect(reverse("auctions:index"))
def logout(request):
if request.method == 'POST':
auth.logout(request)
return redirect('home')
def logoutUser(request):
logout(request)
return render(request,'users/signup.html')
def logout_views(request):
logout(request)
return redirect('accounts:login')
def dispatch(self, request, *args, **kwargs):
logout(request)
return redirect('/blog/')
def log_out(request):
logout(request)
return redirect('sign_in')
def logoutUser(request):
logout(request)
return HttpResponseRedirect(reverse("homepage"))
def get(self,request):
logout(request)
return HttpResponseRedirect(reverse("user_login"))
