def login_view(request):
print(request.POST)
form = LoginForm()
if request.method == 'POST':
form = LoginForm(request.POST)
return render(request, "login.html", {'form': form})
def login_request(request, redirect_field_name=REDIRECT_FIELD_NAME):
"""
Displays the login form and handles the login action.
"""
if request.user.is_authenticated():
return HttpResponseRedirect('/accounts/profile/')
redirect_to = request.REQUEST.get(redirect_field_name, '')
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
if not form.cleaned_data.get('remember'):
request.session.set_expiry(0)
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
return HttpResponseRedirect(redirect_to)
else:
return render_to_response('login.html', {'form': form},
context_instance=RequestContext(request))
else:
return render_to_response('login.html', {'form': form},
context_instance=RequestContext(request))
else:
form = LoginForm()
context = {'form': form}
return render_to_response('login.html', context,
context_instance=RequestContext(request))
def login_user(request):
logger.debug("login_user called by user %s" % request.user)
if request.method == 'POST':
form = LoginForm(request.POST)
logger.debug("Request of type POST, received form, valid: %s" % form.is_valid())
if form.is_valid():
user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
logger.debug("Authentication attempt with supplied credentials. Received user %s" % user)
if user is not None:
if user.is_active:
logger.info("Successful login attempt from user %s" % user)
login(request, user)
redirect_to = request.POST.get('next', request.GET.get('next', ''))
if not redirect_to:
redirect_to = 'auth_dashboard'
return redirect(redirect_to)
else:
logger.info("Login attempt failed for user %s: user marked inactive." % user)
messages.warning(request, 'Your account has been disabled.')
else:
logger.info("Failed login attempt: provided username %s" % form.cleaned_data['username'])
messages.error(request, 'Username/password invalid.')
return render(request, 'public/login.html', context={'form': form})
else:
logger.debug("Providing new login form.")
form = LoginForm()
return render(request, 'public/login.html', context={'form': form})
def login_view(request):
error = None
next = request.GET.get('next', None)
if request.user.is_authenticated():
return redirect(reverse('home'))
if request.POST:
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
if request.GET.get('next') is not None:
print('here')
return redirect(request.GET["next"])
return redirect(reverse('home'))
error = 'Invalid credentials.'
else:
form = LoginForm()
return render(request, 'auth/login.html', {
'form': form,
'error': error,
'next': next
})
def login_view(request):
context = {}
if request.user:
user = request.user
group = user.groups.all()
if group.filter(name=PROVINCE_USER).count():
return redirect('manager.question_table')
elif group.filter(name=SCHOOL_USER).count():
return redirect('school.question_table')
if request.method == 'GET':
login_form = LoginForm()
context['login_form'] = login_form
return render(request, 'authentication/login.html', context)
else:
login_form = LoginForm(request.POST)
if login_form.is_valid():
cd = login_form.cleaned_data
username = cd['username']
password = cd['password']
user = authenticate(**cd)
if user is not None:
login(request, user)
group = user.groups.all()
if group.filter(name=PROVINCE_USER).count():
return redirect('manager.question_table')
elif group.filter(name=SCHOOL_USER).count():
return redirect('school.question_table')
else:
context['errors'] = 'Invalid role'
else:
context['errors'] = 'Invalid User'
context['login_form'] = login_form
return render(request, 'authentication/login.html', context)
def login_mobile(request):
user_agent = get_user_agent(request)
error_message = None
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
return HttpResponseRedirect(reverse('index'))
else:
error_message = 'Username or password is incorrect'
else:
error_message = 'Invalid input'
else:
form = LoginForm()
context = {
'form': form,
'error_message': error_message,
'mobile': user_agent.is_mobile,
}
return render(request, 'login_mobile.html', context)
def loginView(request):
message_after = ""
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(request,
username=data["username"],
password=data["password"])
if user is not None:
login(request, user)
return HttpResponseRedirect(
request.GET.get("next", reverse("home")))
else:
message_after = """Credentials supplied do not match our records.
Please try again."""
form = LoginForm()
return render(
request,
"../templates/general_form.html",
{
"form": form,
"message_after": message_after
},
)
def login_mobile(request):
user_agent = get_user_agent(request)
error_message = None
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
return HttpResponseRedirect(reverse('index'))
else:
error_message = 'Username or password is incorrect'
else:
error_message = 'Invalid input'
else:
form = LoginForm()
context = {
'form': form,
'error_message': error_message,
'mobile': user_agent.is_mobile,
}
return render(request, 'login_mobile.html', context)
def login_view(request):
if request.method == "POST":
form = LoginForm(request.POST)
signup_form = SignupForm(request.POST)
if Author.objects.filter(
username=form.data["username"]).first() == None:
if signup_form.is_valid():
data = signup_form.cleaned_data
Author.objects.create_user(username=data["username"],
email=data["email"],
password=data["password"])
return HttpResponseRedirect(
request.GET.get("next", reverse("login")))
if form.is_valid():
data = form.cleaned_data
user = authenticate(request,
username=data["username"],
password=data["password"])
if user:
login(request, user)
messages.info(request,
f"You are now logged in as {user.username}")
return HttpResponseRedirect(
request.GET.get("next", reverse("homepage")))
else:
messages.error(request, "Invalid username or password")
else:
messages.error(request, "Invalid username or password")
form = LoginForm()
signup_form = SignupForm()
return render(request, "login.html", {
"form": form,
"signup_form": signup_form
})
def login(request, user=None, next=None):
"""
Authenticate and login a user, returning the homepage or a redirect(next) url
:param request:
:param user:
:param next:
:return:
"""
if user:
_login(request, user)
if next:
return redirect(next)
else:
return redirect("home")
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get("username")
password = form.cleaned_data.get("password")
user = authenticate(username=username, password=password)
next_url = next or request.GET.get('next')
if user is not None:
_login(request, user)
if next_url:
return redirect(next_url)
else:
return redirect("home")
else:
messages.error(request, "Invalid username or password!")
return redirect("authentication:auth_get")
return redirect("authentication:auth_get")
def login(request):
if request.user.is_authenticated():
redirect_to = request.REQUEST.get('next') or '/'
return HttpResponseRedirect(redirect_to)
#return HttpResponseRedirect('/')
if request.method == 'GET':
c = {}
c.update(csrf(request))
c['form'] = LoginForm()
return render_to_response('authentication/login.html', c)
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
data = form.clean()
user = authenticate(username=data['username'],
password=data['password'])
if user and user.is_active:
auth.login(request, user)
redirect_to = request.REQUEST.get('next') or '/'
return HttpResponseRedirect(redirect_to)
else:
c = {}
c.update(csrf(request))
c['error'] = 'this username could not be authenticated. Please ensure this user exists and has been activated before logging in'
c['form'] = form
return render_to_response('authentication/login.html', c)
c = {}
c.update(csrf(request))
c['form'] = form
c['error'] = 'the username and/or password is incorrect'
return render_to_response('authentication/login.html', c)
return HttpResponseRedirect('/')
def login(request):
c = {}
c.update(csrf(request))
envoi = False
error = False
if request.method == "POST": # S'il s'agit d'une requête POST
form = LoginForm(request.POST) # On récupère les données
if form.is_valid(): # On vérifie que les données envoyées sont valides
username = form.cleaned_data["email"] # L'identifiant est l'adresse e-mail
password = form.cleaned_data["password"]
user = auth.authenticate(username=username, password=password)
# Si l'authentication s'est bien passée, on récupère le profil
if user is not None:
auth.login(request, user)
request.session["session_user_id"] = user.id
return HttpResponseRedirect("../../")
# Sinon, on renvoie une erreur
else:
error = True
error_message = "Invalid informations"
else:
error = True
error_message = "Invalid informations"
else: # Si ce n'est pas du POST, c'est probablement une requête GET
form = LoginForm() # Nous créons un formulaire vide
return render(request, "authentication/login.html", locals())
def test_invalid_login_form_no_password(self):
"""
test a a valid login form
"""
post_dict = {'username': '******', 'password': ''}
form = LoginForm(post_dict)
self.assertFalse(form.is_valid())
def test_valid_login_form(self):
"""
test a a valid login form
"""
post_dict = {'username': '******', 'password': '******'}
form = LoginForm(post_dict)
self.assertTrue(form.is_valid())
def test_required_recaptcha(self):
"""Tests required condition for recaptcha field"""
form = LoginForm({
"username": "******",
"password": "******",
"recaptcha_response_field": ""
})
self.assertFalse(form.is_valid())
def loginpage(request):
formobj = LoginForm(request.POST or None)
if formobj.is_valid():
username = formobj.cleaned_data.get("username")
userobj = User.objects.get(username__iexact=username)
login(request, userobj)
return HttpResponseRedirect(reverse("homepage"))
else:
return render(request, "login.html", {"form": formobj})
def test_form_valid_data(self):
form = LoginForm(data={
'email': "*****@*****.**",
'password': "******"
})
self.assertTrue(form.is_valid())
self.assertEqual(len(form.errors), 0)
# python manage.py test authentication
def post(self, request: HttpRequest):
form = LoginForm(request.POST)
if not form.is_valid():
return render(
request,
"authentication/login.html",
{
"next": request.POST.get("next", ""),
"form": form
},
)
username_email = form.cleaned_data["username_email"]
password = form.cleaned_data["password"]
try:
# Try login by email
user_by_email = UserModel.objects.get(email=username_email)
user = authenticate(username=user_by_email.username,
password=password)
except ObjectDoesNotExist:
# Try login by username
user = authenticate(username=username_email, password=password)
if user:
# Login user
login(request, user)
# If user didn't check remember_me
# session will expire on browser close
if not form.cleaned_data.get("remember_me"):
request.session.set_expiry(0)
# If url has next parameter
# and the url is local (starts with '/' )
# redirect user to the next url
next_url = request.POST.get("next")
if next_url and next_url.startswith("/"):
return redirect(next_url)
# If next didn't exist or wasn't local
# redirect to learning home
return redirect("learning:home")
form.add_error("", "نام کاربری یا رمز عبور اشتباه است")
return render(
request,
"authentication/login.html",
{
"next": request.POST.get("next", ""),
"form": form
},
)
def login_view(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(request, username=data.get('username'), password=data.get('password'))
if user:
login(request, user)
return HttpResponseRedirect(reverse('homepage'))
form = LoginForm()
return render(request, 'loginform.html', {'form': form})
def login_view(request):
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(request, username=data.get("username"), password=data.get("password"))
if user:
login(request, user)
return HttpResponseRedirect(reverse("homepage"))
form = LoginForm()
return render(request, "generic_form.html", {"form": form})
def post(self, req):
form = LoginForm(req.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(
req,
username=data['username'],
password=data['password'],
)
if user:
login(req, user)
return HttpResponseRedirect(req.GET.get('next', '/'))
def loginview(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(request, username=data['username'], password=data['password'])
if user:
login(request, user)
return HttpResponseRedirect(reverse('homepage'))
form = LoginForm()
html = 'base_form.html'
return render(request, html, {'form': form})
def post(self, request):
form = LoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(
username=data['username'],
password=data['password']
)
print(data)
if user:
login(request, user)
return redirect(request.GET.get('next'), reverse('homepage'))
return render(request, 'login.html', {'form': form})
def post(self, request):
form = LoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(request,
username=data.get("username"),
password=data.get("password"))
if user:
login(request, user)
return HttpResponseRedirect(
request.GET.get('next', reverse('homepage')))
else:
return render(request, "generic_form.html", {"form": form})
def signin(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/')
args = {}
args['form'] = LoginForm()
if request.POST:
newuser_form = LoginForm(request.POST)
if newuser_form.is_valid():
auth.login(request, newuser_form.cleaned_data['user'])
return HttpResponseRedirect('/')
else:
args['form'] = newuser_form
return render(request, 'login.html', args)
def test_username_maxlen(self):
"""Tests max length attribute of username field"""
form_instace = LoginForm()
field_length = form_instace.fields['username'].max_length
django_length = User._meta.get_field('username').max_length
self.assertEqual(field_length, django_length)
random_username = (''.join(
choice(ascii_uppercase) for i in range(field_length + 1)))
form = LoginForm({
"username": random_username,
"password": "******",
"recaptcha_response_field": ""
})
self.assertFalse(form.is_valid())
def loginview(request):
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(request,
username=data['username'],
password=data['password'])
if user:
login(request, user)
return HttpResponseRedirect(
request.GET.get('next', reverse('homepage')))
form = LoginForm()
return render(request, 'generic_form.html', {'form': form})
def login_view(request):
context = {}
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(request,
username=data['username'],
password=data['password'])
if user:
login(request, user)
return redirect('home')
form = LoginForm()
context.update({'form': form})
return render(request, 'login.html', context)
def post(self, request):
form = LoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(request,
username=data['username'],
password=data['password'])
if user:
login(request, user)
return HttpResponseRedirect(
request.GET.get('next', reverse('homepage')))
messages.error(request, "Invalid username or password.")
return HttpResponseRedirect(reverse('login'))
messages.error(request, "Invalid form. Please refresh the page.")
return HttpResponseRedirect(reverse('login'))
def log_in(request):
if request.user.is_authenticated():
return redirect('/')
else:
if request.method == 'POST':
form = LoginForm(request.POST)
if not form.is_valid():
return render(request, 'login.html', {'form': form})
else:
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user = authenticate(username=username, password=password)
login(request, user)
return redirect('/')
else:
return render(request, 'login.html', {'form': LoginForm()})
def login_register_page(request):
# This view checks whether the user is authenticated. If not it shows the login page.
if request.user.is_authenticated:
return redirect(settings.LOGIN_REDIRECT_URL)
else:
context = {'login_form': LoginForm(), 'register_form': RegisterForm()}
return render(request, "registration/login_register.html", context)
def login_view(request):
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = authenticate(request,
username=data.get('username'),
password=data.get("password"))
if user:
login(request, user)
# return render(request, 'index.html', {"form": form})
return HttpResponseRedirect(
request.GET.get('next', reverse("homepage")))
form = LoginForm()
return render(request, 'login.html', {"form": form})
def loginView(request, template_name="authentication/login.html"):
if request.user.is_authenticated():
return HttpResponseRedirect('/')
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
# the password verified for the user
if user.is_active:
login(request, user)
return HttpResponseRedirect('/')
def get(self, req):
form = LoginForm()
context = {
'form': form,
'header': "Login as a User",
'logging_in': True,
}
return render(req, 'forms.html', context)
def login_view(request):
form = LoginForm(request.POST or None)
params = {'form': None, 'message': None}
if request.method == 'POST':
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
return redirect("/")
else:
params['message'] = 'Неверно введенные данные'
else:
params['message'] = 'Заполните все поля'
params['form'] = form
return TemplateResponse(request, "registration/login.html", params)
def post(self, request):
form = LoginForm(request.POST)
title = 'Login'
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = authenticate(request, username=username, password=password)
if user is not None:
login(request, user)
return redirect('index')
else:
messages.error(request, 'Username or Password is incorrect.')
context = {'form': form, 'title': title}
return render(request, 'authentication/generic_form.html',
context)
context = {'form': form}
return render(request, 'authentication/index.html', context)
def login_view(request):
# POST request handling
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = authenticate(request, username=username, password=password)
if user:
login(request, user=user)
if request.GET.get('next'):
redirect_path = request.GET['next']
return HttpResponseRedirect(redirect_path)
else:
return HttpResponseRedirect(reverse('homepage'))
else:
form = LoginForm()
return render(
request, 'authentication/login.html', {
'page_title': 'Log In',
'form': form,
'error': 'Invalid Username/Password'
})
# GET request handling
form = LoginForm()
return render(request, 'authentication/login.html', {
'page_title': 'Log In',
'form': form
})
def login_poll(request):
error_login = None
login_form = LoginForm()
if request.user.is_authenticated():
return HttpResponseRedirect(reverse('polls:index'))
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
login_form = LoginForm(request.POST)
if login_form.is_valid():
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
return HttpResponseRedirect(reverse('polls:index'))
else:
error_login = "******"
return render_to_response("authentication/login.html", {'form': login_form, 'next': request.GET.get('next', ''),'errors':dict(login_form.errors.viewitems()),'error_login':error_login},
context_instance=RequestContext(request))
def post(self, request, *args, **kwargs):
data = RequestUtils.get_parameters(request)
form = LoginForm(data)
try:
if form.is_valid():
user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
if user is not None:
if user.is_active:
login(request, user)
return HttpResponse('login valid')
else:
raise AuthenticationException('User is not active')
else:
raise AuthenticationException('Can not authenticate user')
else:
print(form.errors)
return HttpResponse('can not login')
except User.DoesNotExist:
return HttpResponse('can not login')
def login_user(request):
event_list = Event.objects.order_by('-time_start')[:3]
article_list = Article.objects.order_by('-pub_date')[:3]
try:
door_status = DoorStatus.objects.get(name='hackerspace').status
except DoorStatus.DoesNotExist:
door_status = True
user_agent = get_user_agent(request)
error_message = None
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
return HttpResponseRedirect(reverse('index'))
else:
error_message = 'User is not activated'
else:
error_message = 'Username or password is incorrect'
else:
error_message = 'Invalid input'
else:
form = LoginForm()
context = {
'article_list': article_list,
'event_list': event_list,
'form': form,
'door_status': door_status,
'error_message': error_message,
'mobile': user_agent.is_mobile,
}
return render(request, 'index.html', context)
def post(self, request):
"""
Handling POST method
:param json file with username and password
:return: HttpResponse with superuser status and code 200 if user is invited or
HttpResponseBadRequest if request contain incorrect data
"""
data = json.loads(request.body)
login_form = LoginForm(data)
if not login_form.is_valid():
return HttpResponseBadRequest('Invalid input data', status=401)
username = data.get('username', None)
password = data.get('password', None)
user = auth.authenticate(username=username, password=password)
if user:
role = model_to_dict(User.objects.get(username=username))
response = HttpResponse('is_supeuser', status=200)
response.set_cookie('role', value=role['is_superuser'])
auth.login(request, user)
return response
else:
return HttpResponseBadRequest("Incorrect email or password", status=401)
def user_registration(request):
"""
A view for allowing users to register themselves or as an organization
"""
title = 'Registration'
form = UserRegistration(request.POST or None)
login_form = LoginForm(request.POST or None)
context = {
'form':form,
'login_form': login_form,
'title':title
}
# print form.is_valid()
if form.is_valid():
"""
tests if an email has already been used
"""
# print form.is_valid()
if User.objects.filter(email=form.cleaned_data['email']).exists(): # tests for previously used emails
error = "Email already in use"
context = {
'title': title,
'error': error,
'form': form
}
if form.cleaned_data['password'] != form.cleaned_data['confirm_password']: # tests for non matching passowrds
error = "Passwords don't match"
context = {
'title': title,
'error': error,
'form': form
}
if len(form.cleaned_data['password']) < 8: # tests for too short passwords (less than 8 characters)
error = "Password is too short, must be at least 8 characters"
context = {
'title': title,
'error': error,
'form': form
}
else:
try:
user = User.objects.create_user( # create a new user object
email=form.cleaned_data['email'],
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
username=form.cleaned_data['email'],
# users use their emails as usernames by default
password=form.cleaned_data['password']
)
print "user created"
Organization(identifier=form.cleaned_data['org_name'], name =form.cleaned_data['org_name'], website = form.cleaned_data['website'], contact = form.cleaned_data['contact'], description = form.cleaned_data['description'], user=user).save()
except IntegrityError: # prevents a user from registering a previously used username
error = 'Username already taken'
context = {
'title': title,
'form': form,
'error': error
}
return render(request, 'homepage/registration_template.html', context)
auth_user = authenticate(username=form.cleaned_data['email'], password=form.cleaned_data['password'])
login(request, auth_user)
return redirect('/dashboard/', context)
return render(request, 'homepage/registration_template.html', context)
if login_form.is_valid():
auth_user = authenticate(username=form.cleaned_data['email'], password=form.cleaned_data['password'])
login(request, auth_user)
return redirect('/dashboard/', context)
return render(request, 'homepage/registration_template.html', context)
