def login(request):
form = LoginForm(request.POST)
message = {}
if request.method == 'POST':
if form.is_valid():
# Autentica o usuário
usuario = authenticate(username=form.cleaned_data.get('username'),
password=form.cleaned_data.get('password'))
# Verifica se o usuário existe
if usuario is not None:
# Verifica se o usuário está ativo
if usuario.is_active:
login_(request, usuario)
message = {'message': 'Login realizado com sucesso !', 'level': 'success'}
else:
message = {'message': u'Seu usuário foi desativo !', 'level': 'danger'}
else:
message = {'message': u'Seu usuário ou senha estão incorretos !', 'level': 'danger'}
else:
response = JsonResponse(form.errors)
response.status_code = 500
return response
return JsonResponse(message)
def post(self, request):
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=User.objects.get(username= request.POST['username']), password=request.POST['password'])
login(request, user)
return redirect('materias_de_docente')
else:
return render(request, 'login.html', {'form': form})
def login():
if g.user is not None and g.user.is_authenticated():
# TODO: Already logged in. Move to a default after-login page.
# For now asks to logout
return 'Now logged in <a href="logout">Logout</a>'
form = LoginForm()
if form.validate_on_submit():
return oid.try_login(form.openid.data, ask_for = ['nickname', 'email'])
return render_template('/login.html', form = form)
def post(self, request):
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(
username=User.objects.get(username=request.POST['username']),
password=request.POST['password'])
login(request, user)
return redirect('materias_de_docente')
else:
return render(request, 'login.html', {'form': form})
def post(self, request):
form = LoginForm(request.POST)
self.context['form'] = form
if form.is_valid():
u = authenticate(username=form.cleaned_data['usuario'],
password=form.cleaned_data['senha'])
login(request, u)
return render_to_response(self.template_name,
self.context,
RequestContext(request))
def home(request):
if request.method == 'POST':
#import pdb;pdb.set_trace()
form = LoginForm(request.POST)
if form.is_valid():
user = form.cleaned_data['user']
login(request, user)
return redirect('profile')
else:
form = LoginForm()
return render(request, 'core/home.html', {'form': form})
def login():
form = LoginForm(request.form)
if form.validate_on_submit():
user = User.get_or_none(User.email_address == form.email_address.data)
if user and check_password_hash(user.password, form.password.data):
Log.insert(user_id=user.id, action='LOGIN').execute()
session['user'] = model_to_dict(user)
flash("Welcome back, {}!".format(user.first_name))
return redirect(request.args.get('next', url_for('main.index')))
return render_template('main/login.html', form=form)
def core_login(request):
form = LoginForm(request.POST or None)
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=request, user=user)
return redirect(reverse('core_home', args=['login_success']))
return render(request, 'core/login.html', locals())
def test_valid_login_form(self):
"""
Test to check that given valid inforamtion
the form will work correctly.
"""
form = LoginForm({'username': '******', 'password': '******'})
# check everything is correct
self.assertTrue(form.is_valid())
self.assertEquals(form.cleaned_data['username'], 'admin')
self.assertEquals(form.cleaned_data['password'], 'password')
def test_form_username_missing(self):
form_data = {
'password': '******',
}
form = LoginForm(data=form_data)
# Data that was entered is incorrect
self.assertFalse(form.is_valid())
# Ensure that only one error was given
self.assertTrue(form.has_error('username'))
self.assertEqual(len(form.errors.as_data()), 1)
def login(request):
if request.method == 'POST':
form = LoginForm(request.POST)
user = authenticate(username=form.request['username'],
password=form.request['password'])
if user is not None:
django_login(request, user)
return redirect('home')
else:
form = LoginForm()
return render(request, 'registration/login.html', {'form': form})
def index(request):
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password')
user = authenticate(username=username, password=raw_password)
login(request, user)
return redirect('profile')
else:
form = LoginForm()
return render(request, 'index.html', {'form': form})
def post(self, request, *args, **kwargs):
form = LoginForm(request.POST)
if not form.is_valid():
return redirect(settings.LOGIN_URL)
user = authenticate(username=form.cleaned_data.get('username'),
password=form.cleaned_data.get('password'))
if user is not None and user.is_active:
login(request, user)
return redirect(settings.LOGIN_REDIRECT_URL)
return redirect(settings.LOGIN_URL)
def login_user(request):
"""
Login request handler
"""
response = reply_object()
form = LoginForm(request.POST, request=request)
if form.is_valid():
response["code"] = settings.APP_CODE["LOGIN"]
response["next_view"] = reverse('home')
else:
response["code"] = settings.APP_CODE["FORM ERROR"]
response["errors"] = form.errors
return HttpResponse(simplejson.dumps(response))
def post(self, request, *args, **kwargs):
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)
return redirect(reverse('core:chat_get'))
return render(request, 'form.html', {'form': form, 'form_action': reverse('core:login')})
def login(request):
login_form = LoginForm()
redirect_url = reverse('homepage', args=[])
redirect_url = request.GET.get('next') or redirect_url
if request.method == 'POST' and 'login_form' in request.POST:
login_form = LoginForm(request.POST)
if login_form.is_valid():
return login_form.login(request, redirect_url=redirect_url)
return render(request, "login.html", {
"login_form": login_form,
})
def login(request):
Ticket = "not submitted"
if request.method == "POST":
# Get the posted form
MyLoginForm = LoginForm(request.POST)
if MyLoginForm.is_valid():
Ticket = MyLoginForm.cleaned_data['ClientTicketID']
Summary = MyLoginForm.cleaned_data['Summary']
Description = MyLoginForm.cleaned_data['Description']
else:
MyLoginForm = LoginForm()
return render(request, 'core/loggedin.html', {"ClientTicketID": Ticket, "Summary": Summary, "Description": Description})
def test_form_incorrect(self):
form_data = {
'username': '******',
'password': '******',
}
form = LoginForm(data=form_data)
# Data that was entered is incorrect
self.assertFalse(form.is_valid())
# Ensure that only one (general) error was given
self.assertEqual(len(form.errors.as_data()), 1)
self.assertEqual(len(form.non_field_errors().as_data()), 1)
self.assertEqual(form.non_field_errors().as_data()[0].code,
'ERROR_INVALID_LOGIN')
def handle_login_error(login_error):
form = LoginForm()
return render_to_response(template, {
'login_error': login_error,
'login_form': form,
},
context_instance=RequestContext(request))
def get(self, request):
"""
Get method for view that will provide login form.
"""
next_url = request.GET.get('next', None)
context = {'form': LoginForm(), 'next': next_url}
return render(request, 'core/login.html', context)
def login():
if current_user.is_authenticated:
return redirect(url_for('home'))
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data.lower()).first()
if user and bcrypt.check_password_hash(user.password,
form.password.data):
login_user(user, remember=form.remember.data)
next_page = request.args.get('next')
return redirect(next_page) if next_page else redirect(
url_for('home'))
else:
flash('Login failed, please check email and password.', 'danger')
return render_template('login.html', title='Login', form=form)
def login(request):
next_redirect = request.GET.get('next')
if request.user.is_authenticated():
if not next_redirect:
return HttpResponseRedirect(
reverse('profile', kwargs={'user_id': request.user.id}))
else:
return HttpResponseRedirect(next_redirect)
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = LoginForm(request.POST)
# check whether it's valid:
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
if '@' in username and '.' in username:
uqs = User.objects.filter(email=username)
username = uqs.first().username
user = djauth.authenticate(username=username, password=password)
if user is None:
errors = form._errors.setdefault(NON_FIELD_ERRORS, ErrorList())
errors.append(u"Could not authenticate you.")
else:
djauth.login(request, user)
next_redirect = request.POST.get('next')
if not next_redirect:
return HttpResponseRedirect(
reverse('profile', kwargs={'user_id':
request.user.id}))
else:
return HttpResponseRedirect(next_redirect)
# if a GET (or any other method) we'll create a blank form
else:
form = LoginForm()
return render(request, 'auth/login.html', {
'form': form,
'next': next_redirect
})
def login_user(request, template='index.html', redirect_url=None):
def handle_login_error(login_error):
form = LoginForm()
return render_to_response(template, {
'login_error': login_error,
'login_form': form,
},
context_instance=RequestContext(request))
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
redirect_url = redirect_url or form.cleaned_data.get(
'redirect_url')
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
# Redirect to a success page.
login(request, user)
if redirect_url:
return HttpResponseRedirect(redirect_url)
else:
return render_to_response(
template, {'login_succeeded': True},
context_instance=RequestContext(request))
else:
# Return a 'disabled account' error message
error = u'Account disabled'
else:
# Return an 'invalid login' error message.
error = u'Invalid login'
else:
error = u'Login form is invalid'
return handle_login_error(error)
else:
form = LoginForm() # An unbound form
form.fields['redirect_url'].initial = request.GET.get('next', '/')
return render_to_response(template, {
'login_error': "You must first login",
'form': form
},
context_instance=RequestContext(request))
def do_login(request):
error_message = u""
if request.method == 'POST':
login_form = LoginForm(request.POST)
if login_form.is_valid():
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
return HttpResponseRedirect(
reverse('core_home')
)
else:
error_message = "This account is disabled."
error_message = "Invalid login details provided."
else: # GET
# HACK: Suitable for NFC demo only.
# Check if the NFC token has been supplied as a URL parameter. If it
# has, authenticate using this.
nfc_token = request.GET.get('nfc_token')
if nfc_token is not None:
user = authenticate(nfc_token=nfc_token)
login(request, user)
return HttpResponseRedirect(
reverse('core_home')
)
else:
login_form = LoginForm()
return render_to_response(
'login.html',
context_instance=RequestContext(
request,
{'login_form': login_form, 'error_message': error_message}
)
)
def signin(request):
if request.method == "POST":
signin_form = LoginForm(data=request.POST)
if signin_form.is_valid():
name = signin_form.cleaned_data['username']
password = signin_form.cleaned_data['password']
user = authenticate(request,
username=name,
password=password,
is_staff=0)
if user is not None and user.is_staff:
login(request, user)
messages.success(request, 'Login successful')
return redirect('core:view_user')
signin_form = LoginForm(data=request.POST)
context = {'signin_form': signin_form}
messages.error(request, 'Wrong username or password')
return render(request, 'login.html', context)
signin_form = LoginForm()
context = {'signin_form': signin_form}
return render(request, 'login.html', context)
def login_view(request):
form = LoginForm(data=request.POST or None)
context = {
'form': form,
}
if request.method == 'POST' and form.is_valid():
user = form.get_user()
login(request, user)
chat, created = Chat.objects.get_or_create(name='chat')
chat.user.add(user.id)
logger.info('User %s log in', user)
return redirect(settings.LOGIN_REDIRECT_URL)
return render(request, 'registration/login.html', context)
def do_login(request):
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
print(username, password)
user = authenticate(request, username=username, password=password)
if user is not None:
login(request, user)
request.session['success'] = "You are now logged in."
messages.success(request, 'You are now logged in.')
return HttpResponseRedirect('/')
messages.error(request, "The username and password were incorrect.")
return HttpResponseRedirect(reverse('login'))
def login_user(request, template='index.html', redirect_url=None):
def handle_login_error(login_error):
form = LoginForm()
return render_to_response(template, {
'login_error' : login_error,
'login_form' : form,
}, context_instance=RequestContext(request))
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
redirect_url = redirect_url or form.cleaned_data.get('redirect_url')
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
# Redirect to a success page.
login(request, user)
if redirect_url:
return HttpResponseRedirect(redirect_url)
else:
return render_to_response(template, {
'login_succeeded': True
}, context_instance=RequestContext(request))
else:
# Return a 'disabled account' error message
error = u'Account disabled'
else:
# Return an 'invalid login' error message.
error = u'Invalid login'
else:
error = u'Login form is invalid'
return handle_login_error(error)
else:
form = LoginForm() # An unbound form
form.fields['redirect_url'].initial = request.GET.get('next', '/')
return render_to_response(template, {
'login_error': "You must first login",
'form': form
}, context_instance=RequestContext(request))
def get(self, request):
if request.user.is_authenticated():
return redirect('materias_de_docente')
else:
form = LoginForm()
nombre_institucion = get_institucion_name()
return render(request, 'login.html', {
'form': form,
'nombre_institucion': nombre_institucion
})
def login(request):
if request.session.has_key("user_id") and request.session["user_id"] is not "":
return HttpResponseRedirect("/")
form = LoginForm(initial = {'username':''})
context = { 'name': 'ruby', 'form': form}
flag = -1
if request.POST:
form = LoginForm(request.POST)
if form.is_valid():
flag = form.login(request)
else:
flag = 3
messages.info(request, "Form is invalid")
if flag == 1:
messages.info(request, "username or password is wrong")
if flag == 2 or flag == 0:
return HttpResponseRedirect("/")
else:
return render(request,"login.html", context)
def log_in(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
try:
print(form.cleaned_data.get('contact'))
user = User.objects.get(
contact=form.cleaned_data.get('contact'))
except:
return HttpResponse("Enter Registered Contact Number!")
else:
sms = authy_api.users.request_sms(user.authy_id)
print(sms)
if sms.ok():
return redirect('verify_otp', user.authy_id)
else:
return render(request, "500.html")
else:
form = LoginForm()
return render(request, 'login.html', {'form': form})
def get(self, request):
"""
Show login form
:param request: HttpRequest object
:return: HttpResponse object with rendered login form
"""
form = LoginForm()
context = {'form': form}
return render(request, 'core/login.html', context)
def submit_req(request):
with open('rfc.txt') as json_file:
data = json.load(json_file)
if request.method == "POST":
# Get the posted form
MyLoginForm = LoginForm(request.POST)
if MyLoginForm.is_valid():
data["ns0:Process"]["ns2:Ticket"]["ClientTicketID"] = MyLoginForm.cleaned_data['ClientTicketID']
data["ns0:Process"]["ns2:Ticket"]["Summary"] = MyLoginForm.cleaned_data['Summary']
data["ns0:Process"]["ns2:Ticket"]["Description"] = MyLoginForm.cleaned_data['Description']
else:
MyLoginForm = LoginForm()
json_pretty = json.dumps(data)
context = {
"json_pretty": json_pretty,
}
return render(request, 'core/hello.html', context)
def login_view(request):
if request.method == 'POST':
form = LoginForm(data=request.POST)
if form.is_valid():
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('password')
try:
user = User.objects.get(email=email)
except:
return HttpResponse("User doesn't exist")
if user.password != password:
return HttpResponse("Incorrect password")
user.is_active = True
user.save()
login(request, user)
return redirect('home')
else:
form = LoginForm()
return render(request, 'login.html', {'form': form})
def login(request):
next_redirect = request.GET.get('next')
if request.user.is_authenticated():
if not next_redirect:
return HttpResponseRedirect(reverse('profile', kwargs={'user_id': request.user.id}))
else:
return HttpResponseRedirect(next_redirect)
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = LoginForm(request.POST)
# check whether it's valid:
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
if '@' in username and '.' in username:
uqs = User.objects.filter(email=username)
username = uqs.first().username
user = djauth.authenticate(username=username, password=password)
if user is None:
errors = form._errors.setdefault(NON_FIELD_ERRORS, ErrorList())
errors.append(u"Could not authenticate you.")
else:
djauth.login(request, user)
next_redirect = request.POST.get('next')
if not next_redirect:
return HttpResponseRedirect(reverse('organization-overview'))
else:
return HttpResponseRedirect(next_redirect)
# if a GET (or any other method) we'll create a blank form
else:
form = LoginForm()
return render(request, 'auth/login.html', {'form': form, 'next': next_redirect})
def login():
if not User.query.first():
return redirect(url_for('auth.register'))
if current_user.is_authenticated:
return redirect(url_for('messages.read'))
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(username=form.username.data).first()
if (user is None) or (not check_password_hash(user.password, form.password.data)):
flash('Invalid username or password')
return redirect(url_for('auth.login'))
login_user(user, remember=form.remember_me.data)
next_page = request.args.get('next')
if not next_page or url_parse(next_page).netloc != '':
next_page = url_for('messages.read')
return redirect(next_page)
return render_template('auth/login.html', title='Login', form=form)
def sign_up(request):
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
first_pass = form.cleaned_data["password"]
conf_pass = request.POST.get("confpass", "")
if not conf_pass:
return HttpResponse("Please Enter Confirm password")
if first_pass != conf_pass:
return HttpResponse("Your passwords do not match")
else:
print first_pass
print conf_pass
form.save()
else:
form = LoginForm()
return render(request, "core/login.html", {"form": form})
def auth(request):
if request.method == "POST":
login_form = LoginForm(request.POST)
if login_form.is_valid():
username = login_form.cleaned_data.get('username')
password = login_form.cleaned_data.get('password')
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
nxt = request.GET.get('next')
if nxt:
return redirect(nxt)
else:
return redirect(index)
else:
return render(request, 'login.html', {'login_form': login_form, 'error': True})
else:
return render(request, 'login.html', {'login_form': login_form})
else:
login_form = LoginForm()
return render(request, 'login.html', {'login_form': login_form})
def login_view(request):
if request.method == 'POST':
login_form = LoginForm(request.POST)
if login_form.is_valid():
username = login_form.cleaned_data['username']
password = login_form.cleaned_data['password']
user = authenticate(request, username=username, password=password)
if user is not None:
login(request, user)
return redirect('/')
error_message = ('Invalid login. Please complete the form '
'with your username and password')
return render(request, 'core/login.html', {
'error_message': error_message,
'login_form': login_form,
})
else:
login_form = LoginForm()
return render(request, 'core/login.html', {'login_form': login_form})
def post(self, request):
form = LoginForm(request.POST)
next_page = request.GET.get('next')
print(next_page)
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)
if next_page:
return redirect(next_page)
return redirect('/')
else:
return render(request, 'login.html', {
'form': form,
'message': 'Nie ma takiego uzytkownika'
})
else:
return render(request, 'login.html', {'form': form})
def login_page(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
login = form.cleaned_data['login']
password = form.cleaned_data['password']
user = auth.authenticate(username=login, password=password)
if user is not None and user.is_active:
auth.login(request, user)
if request.is_ajax():
return HttpResponse(content=json.dumps({'success': 'accueil'}))
# return redirect('accueil') # Redirect after POST
else:
if request.is_ajax():
return HttpResponse(content=json.dumps({'error': '/'}))
# return HttpResponse(content=json.dump({'success': 'login_page','errors': form.errors}))
elif request.is_ajax():
errors = json.dumps(form.errors)
return HttpResponse(errors)
else:
form = LoginForm()
return render(request, 'login.html', {'form': form})
def login():
"""Login form, also includes registration link if reg is open."""
if current_user.is_authenticated:
return redirect(url_for("index"))
form = LoginForm()
# @TODO Refactor this around content model
if form.validate_on_submit():
user = User.query.filter_by(username=form.username.data).first()
if user is None or not user.check_password(form.password.data):
flash("Invalid username or password")
return redirect(url_for("login"))
login_user(user, remember=form.remember_me.data)
current_user.last_login = datetime.utcnow()
db.session.commit()
next_page = request.args.get("next")
if not next_page or url_parse(next_page).netloc != "":
next_page = url_for("index")
return redirect(next_page)
return render_template("login.html", title="Sign In", form=form)
