def login_view(request):
if request.method == "POST":
form = LoginForm(request.POST)
next_ = request.POST.get("next", "/")
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(next_)
else:
return rr("registration/login.html",
{"msg": _("Your account is not active.")},
context_instance=RequestContext(request))
else:
return rr("registration/login.html",
{"msg": _("username or password is incorrect.")},
context_instance=RequestContext(request))
else:
next_ = request.GET.get("next", "/")
if request.user.is_authenticated():
return HttpResponseRedirect(next_)
return rr("registration/login.html", {"next": next_},
context_instance=RequestContext(request))
def login_view(request):
if request.user.is_authenticated():
return HttpResponseRedirect(profile_url(request.user))
form = LoginForm(data=request.POST or None)
if form.is_valid():
if not form.cleaned_data['remember']:
request.session.set_expiry(0)
login(request, form.get_user())
if request.session.test_cookie_worked():
request.session.delete_test_cookie()
if 'next' in request.REQUEST:
next = request.REQUEST['next']
if next.startswith('/'):
return HttpResponseRedirect(next)
return HttpResponseRedirect(profile_url(request.user))
request.session.set_test_cookie()
return locals()
def login_view(request):
user_value = ''
password_value = ''
form = LoginForm(request.POST or None)
if form.is_valid():
user_value = form.cleaned_data.get("username")
password_value = form.cleaned_data.get("password")
user = authenticate(username=user_value, password=password_value)
if user is not None:
login(request, user)
context = {'form': form, 'error': 'Успешный вход!'}
return render(request, 'login.html', context)
else:
context = {
'form': form,
'error': 'Не верное сочетание Имени пользователя и Пароля'
}
return render(request, 'login.html', context)
else:
context = {'form': form}
return render(request, 'login.html', context)
def success_installation_handler(sender, **kwargs):
from server.models import ConfigData
from virtualhost.models import User, VirtualHost
ConfigData.objects.create(db_host=kwargs['db_host'],
db_name=kwargs['db_name'],
db_user=kwargs['db_user'],
db_user_pass=kwargs['db_user_pass'])
VirtualHost.objects.create(name=kwargs['xmpp_host'])
user = User.objects.create(username=kwargs['admin_username'],
host=kwargs['xmpp_host'],
is_admin=True)
user.set_password(kwargs['admin_password'])
user.save()
request = kwargs['request']
data = {
'username': '******'.format(kwargs['admin_username'],
kwargs['xmpp_host']),
'password': '******'.format(kwargs['admin_password']),
'source_browser': request.META['HTTP_USER_AGENT'],
'source_ip': get_user_ip(request)
}
form = LoginForm(data)
if form.is_valid():
login(request, form.user)
request.session['_auth_user_username'] = kwargs['admin_username']
request.session['_auth_user_host'] = kwargs['xmpp_host']
def login(request):
if request.user['is_authenticated']:
return HttpResponseRedirect('/')
login_form = LoginForm()
register_form = RegistrationForm()
next = request.REQUEST.get('next')
if 'kind' in request.POST:
if request.POST['kind'] == 'login':
login_form = LoginForm(request.POST)
if login_form.is_valid():
username = login_form.get_username()
request.session['username'] = username
if next:
return HttpResponseRedirect(next)
return HttpResponseRedirect('/user')
elif request.POST['kind'] == 'register':
register_form = RegistrationForm(request.POST)
if register_form.is_valid():
username = register_form.save()
request.session['username'] = username
if next:
return HttpResponseRedirect(next)
return HttpResponseRedirect('/user/welcome')
context = {
'login_form': login_form,
'register_form': register_form,
'next': next,
}
return render_to_response(
'auth/login.html', context, context_instance=RequestContext(request))
def login():
# Render the homepage template on the / route
register_form = RegistrationForm(prefix="register_form")
if register_form.validate_on_submit() and register_form.submit.data:
user = User(
username=register_form.username.data, email=register_form.email.data
)
user.password(register_form.password.data)
db.session.add(user)
db.session.commit()
flash("You are registered")
return redirect(url_for("auth.login"))
# on submit, go to database, check user exists, verify password, log-in.
login_form = LoginForm(prefix="login_form")
if login_form.validate_on_submit() and login_form.submit.data:
user = User.query.filter_by(email=login_form.email.data).first()
if verify_login(user, login_form.password.data):
login_user(user)
return redirect(url_for("home.dashboard"))
else:
flash("Invalid email or password")
return render_template(
"auth/login.html",
title="Login",
register_form=register_form,
login_form=login_form,
)
def login():
form = LoginForm()
if form.validate_on_submit():
cursor.execute(
"SELECT employee_id FROM employee WHERE employee_id = %s",
(form.username.data, ))
if cursor.fetchone():
cursor.execute(
"SELECT password FROM employee WHERE employee_id = %s",
(form.username.data, ))
if cursor.fetchone()[0] == form.password.data:
global username
global role
username = form.username.data
cursor.execute(
"SELECT role FROM employee WHERE employee_id = %s",
(form.username.data, ))
role = cursor.fetchone()[0]
flash('You have successfully been successfully logged in!')
return redirect(url_for('user.dashboard'))
flash('Invalid email or password.')
return render_template('auth/login.html',
form=form,
title='Login',
isadmin=isadmin,
username=username,
role=role)
def login_view(request):
if request.method == 'POST':
form = LoginForm(data=request.POST)
if form.is_valid():
user = authenticate(username=request.POST['username'],
password=request.POST['password'])
# Authenticated and not banned
if user is not None and user.is_active:
login(request, user)
# Linking DogeUser and Django's user models
try:
doge_user = DogeUser.objects.get(user_id=user.id)
except ObjectDoesNotExist:
try:
doge_user = DogeUser.objects.get(login=user.username)
doge_user.user = user
doge_user.save()
except ObjectDoesNotExist:
# Link failed (not listed in ldap)
pass
# Handling a possible redirection
next_url = request.POST.get('next', reverse('index'))
return HttpResponseRedirect(next_url)
else:
if request.user.is_authenticated():
return HttpResponseRedirect(reverse('index'))
form = LoginForm()
return render(request, 'auth/login.html', {'form': form})
def index():
if g.user is None:
login_form = LoginForm(prefix="login")
registration_form = RegistrationForm(prefix="register")
button = request.form.get('button')
if button == 'login' and login_form.validate_on_submit():
user = login_form.user
user.touch()
session['username'] = user.username
return redirect(request.args.get('next', url_for('index')))
elif button == 'register' and registration_form.validate_on_submit():
count = User.query.count()
user = User(
registration_form.username.data,
generate_password_hash(registration_form.password.data),
registration_form.email.data,
False,
True,
bool(count == 0),
)
db.session.add(user)
db.session.flush()
email.send_account_created_email(user)
db.session.commit()
session['username'] = user.username
flash('Registration successful! Please check your e-mail so we can verify your address.')
return redirect(url_for('index'))
else:
return render_template('index.html',
login_form=login_form,
registration_form=registration_form)
else:
identity_tokens = list(g.user.identity_tokens.filter_by(enabled=True))
return render_template('index.html', identity_tokens=identity_tokens)
def login(success):
if current_user.is_authenticated:
return redirect(url_for("dashboard"))
form = LoginForm()
register_form = RegisterForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if user is None:
return render_template("pages/login.html",
invalid_credential=True,
form=form,
register_form=register_form,
page_title="Entrar no Twitter")
login_user(user)
return redirect(url_for("dashboard"))
return render_template("pages/login.html",
form=form,
register_form=register_form,
page_title="Entrar no Twitter",
success=success)
def re_authenticate():
if login_fresh():
return redirect(url_for('main.index'))
form = LoginForm()
if form.validate_on_submit() and current_user.validate_password(
form.password.data):
confirm_login()
return redirect_back()
return render_template('auth/login.html', form=form)
def user_login(**kwargs):
""" asychronized login api """
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if user is not None and user.verify_password(form.password.data):
login_user(user)
return dict(success=1)
else:
return dict(fail=1)
def POST(self):
f = LoginForm()
web.header('Content-Type', 'application/json')
try:
if not f.validates():
raise web.unauthorized('Your email or password is wrong')
# return json.dumps({'success':False})
else:
return json.dumps({'success':True})
# raise web.seeother('/admin/')
except web.HTTPError, e:
return json.dumps({'message':e.data})
def login_route():
""" route for logging the user to the system """
form = LoginForm()
if form.validate_on_submit():
user = User.authenticate(form.username.data, form.password.data)
if user:
login(user)
flash(f'welcome {user.username}', 'success')
return redirect(url_for('homepage'))
flash('Invalid credintials', 'danger')
return render_template('/login.html', form=form)
def login(request):
"""
ログイン
"""
form = LoginForm(request.POST or None)
if form.is_valid():
url, obj = get_openid_request(form.cleaned_data['openid_url'])
# セッションにトークンを保持
request.session[CONSUMER_SESSION_KEY] = obj
# OpenID認証ページへリダイレクト
return redirect(url)
return direct_to_template(request, 'auth/login.html', {'form': form})
def test_clean(self):
data = {"email": "*****@*****.**", "password": "******"}
form = LoginForm(data=data)
self.assertTrue(form.is_valid())
if settings.USER_TYPE == "Customer":
self.assertEqual(form.cleaned_data["username"], "*****@*****.**")
self.assertEqual(form.user_cache.username, "*****@*****.**")
else:
self.assertEqual(form.cleaned_data["username"], "*****@*****.**")
self.assertEqual(form.user_cache.username, "*****@*****.**")
def login(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
user = auth.authenticate(username=cd['username'], password=cd['password'])
if user is not None and user.is_active:
auth.login(request, user)
return render_to_response('home.html', locals(), context_instance=RequestContext(request, processors=[custom_proc]))
else:
form = LoginForm()
return render_to_response('login.html', {'form': form}, context_instance=RequestContext(request, processors=[custom_proc]))
def test_clean(self):
data={"email":"*****@*****.**", "password":"******"}
form = LoginForm(data=data)
self.assertTrue(form.is_valid())
if settings.USER_TYPE == "Customer":
self.assertEqual(form.cleaned_data["username"], "*****@*****.**")
self.assertEqual(form.user_cache.username, "*****@*****.**")
else:
self.assertEqual(form.cleaned_data["username"], "*****@*****.**")
self.assertEqual(form.user_cache.username, "*****@*****.**")
def login():
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if user is not None and user.verify_password(form.password.data):
login_user(user, form.remember_me.data)
return redirect(request.args.get('next') or url_for('index'))
flash(u'Неверный e-mail или пароль', 'danger')
for field, errors in form.errors.iteritems():
for error in errors:
flash(u'Ошибка в поле {}. {}'.format(field, error), 'danger')
return render_template('auth/login.html', form=form)
def login_view(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password'])
if user:
login(request, user)
return redirect('user_profile', request.user.id)
# else:
# return render(request, 'registration/login.html')
else:
form = LoginForm()
return render(request, 'registration/login.html', {'form': form})
def post(self, request):
form = LoginForm(request.POST)
context = {"login_form": form}
if form.is_valid():
username = form.data.get("username")
data = {"password": form.data.get("password")}
url = "%s/users/%s/tokens" % (settings.TSURU_HOST, username)
response = requests.post(url, data=json.dumps(data))
if response.status_code == 200:
result = json.loads(response.text)
request.session["tsuru_token"] = result["token"]
return HttpResponseRedirect("/apps")
context["msg"] = "User not found"
return TemplateResponse(request, "auth/login.html", context=context)
def login_view(request):
logged_in = request.user.is_authenticated()
if not logged_in:
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
usuario = request.POST['usuario']
contrasena = request.POST['contrasena']
usuario = authenticate(username=usuario, password=contrasena)
if usuario is not None:
if usuario.is_active:
login(request, usuario)
return HttpResponseRedirect('/inicio/')
else:
return render(
request, 'contacto_formulario.html', {
'subtitulo':
'Usuario no esta activo',
'title':
'Error | Borbolla Metrology',
'texto':
'El usuario no esta activo , favor de ponerse en contacto con el administrador '
})
else:
return render(
request, 'contacto_formulario.html', {
'subtitulo':
'Error de Autentificacion',
'title':
'Error | Borbolla Metrology',
'texto':
'El usuario o contrasena son incorrectos , favor de introducirlos nuevamente'
})
else:
form = LoginForm()
return render(
request, 'contacto_formulario.html', {
'subtitulo': 'Formulario de Acceso',
'form': form,
'title': 'Login | Borbolla Metrology',
'texto': 'Ingrese su usuario y contrasena '
})
return render(
request, 'contacto_formulario.html', {
'subtitulo': 'Formulario de Acceso',
'title': 'Login | Borbolla Metrology',
'texto': 'Ya estas Autentificado '
})
def login():
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if user is None or not user.check_password(form.password.data):
flash('Invalid username or password')
print('Login failed')
return redirect(url_for('auth.login'))
user.authenticate()
db.session.add(user)
db.session.commit()
login_user(user, remember=form.remember_me.data)
return redirect(url_for('home'))
return render_template('login.html', form=form)
def login():
if current_user.is_authenticated:
return redirect(url_for('documents.index'))
form = LoginForm()
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):
return redirect(url_for('auth.login'))
login_user(user, remember=form.remember_me.data)
next = request.args.get('next')
if next:
return redirect(next)
return redirect(url_for('documents.index'))
return render_template('auth/login.html', title='Sign In', form=form)
def login():
if current_user.is_authenticated:
return redirect(url_for('main.index'))
form = LoginForm()
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('Usuário ou senha incorreto')
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('main.index')
return redirect(next_page)
return render_template('login.html', title='Entrar', form=form)
def login():
if g.user.is_authenticated:
return redirect(request.args.get('next') or url_for('mainbp.index'))
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(username = form.username.data,
password = md5((form.password.data + form.username.data).encode('utf-8')).hexdigest()).first()
if user is None:
flash('Invalid login, please try again.')
return redirect(url_for('.login'))
login_user(user)
return redirect(request.args.get('next') or url_for('mainbp.index'))
return render_template('auth/login.html',
title = 'Sign In',
form = form)
def login():
form = LoginForm()
error = None
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
if not user or not check_password_hash(user.password,
form.password.data):
error = 'Please check your login details and try again'
else:
login_user(user)
return redirect(url_for('insights_app.profile'))
return render_template('auth/login.html', form=form, error=error)
def login(request, redirect_uri='/home'):
''' login functionality which returns a empty form when given a GET request
or validates the authentication when given a POST request '''
if request.method == "POST":
login_form = LoginForm(data=request.POST)
if login_form.is_valid():
login_form_cleaned = login_form.cleaned_data
email = login_form_cleaned['email']
redis_obj = Redis()
if account_existence(redis_obj, email) == 1:
user_id = get_key(redis_obj, email)
password = get_password(redis_obj, user_id)
if password == encrypt_password(login_form_cleaned['password']):
auth_token = get_auth_token()
update_auth_token(redis_obj, auth_token, user_id, email)
redirect_uri = request.POST.get('redirect_uri', '/home')
response = HttpResponseRedirect(redirect_uri)
max_age = 7 * 24 * 60 * 60
expires = datetime.datetime.strftime(datetime.datetime.utcnow() + datetime.timedelta(seconds=max_age), "%a, %d-%b-%Y %H:%M:%S GMT")
response.set_cookie('auth', auth_token, max_age=max_age, expires=expires)
response.set_cookie('email', email, max_age=max_age, expires=expires)
return response
redirect_uri = request.POST.get('redirect_uri', '/home')
signup_form = SignUpForm()
return render_to_response(HOME_PAGE_TEMPLATE_PATH,
{
'login_form':login_form,
'signup_form':signup_form,
'redirect_uri':redirect_uri,
'signin_error':'invalid username or password'
},
context_instance=RequestContext(request))
login_form = LoginForm()
signup_form = SignUpForm()
return render_to_response(HOME_PAGE_TEMPLATE_PATH,
{
'login_form':login_form,
'signup_form':signup_form,
'redirect_uri':redirect_uri
},
context_instance=RequestContext(request))
def login():
if current_user.is_authenticated:
return redirect(url_for('main.index'))
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data.lower()).first()
if user is not None and user.validate_password(form.password.data):
if login_user(user, form.remember_me.data):
flash('Login success.', 'info')
return redirect_back()
else:
flash('Your account is blocked.', 'warning')
return redirect(url_for('main.index'))
flash('Invalid email or password.', 'warning')
return render_template('auth/login.html', form=form)
def loginview(request):
html = "login.html"
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'))
else:
form = LoginForm()
context = {'form': form}
return render(request, html, context)
def login():
if current_user.is_authenticated:
return redirect(url_for('hello'))
forml = LoginForm()
if request.method=='POST' and forml.validate_on_submit():
user = User.query.filter_by(username = forml.username.data).first()
if forml.checkx(user = user):
login_user(user, remember = True)
return redirect(url_for('hello'))
else:
print(forml.errors)
print('something gone wrong')
return render_template('login.html', title = 'Login', form = forml)
def login():
form = LoginForm(request.form)
if form.validate():
try:
user = DelhiveryUser.objects.get(email=form.loginemail.data)
except DoesNotExist:
return render_template("delhivery.html",
loginform=form,
registrationform=RegistrationForm())
if user and user.verify_password(form.loginpassword.data):
login_user(user, remember=True)
return redirect(url_for('delhivery_views.index'))
form.loginemail.errors.append("Email or password invalid")
return render_template("delhivery.html",
loginform=form,
registrationform=RegistrationForm())
def login_view(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
##is this a login or sign up
if form.cleaned_data['submitType'] == "Login":
#Login
print 'Login: '******'username']
user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
if user is not None:
login(request, user)
##Logged in!
print 'logged in user: '******'is authed: ' + str(request.user.is_authenticated())
return HttpResponseRedirect('/m/home/')
else:
#Login Failed
errors = form._errors.setdefault("username", ErrorList())
errors.append(u"Your login info is useless!")
return render_to_response('login.html', {'form': form}, context_instance=RequestContext(request))
else:
#Signup
if form.cleaned_data['password'] != form.cleaned_data['password2']:
errors = form._errors.setdefault("password2", ErrorList())
errors.append(u"Passwords do not match!")
print("at signup!")
return render_to_response('login.html', {'form': form, 'signup':'true'}, context_instance=RequestContext(request))
#Create the new user!
print "username: "******" pass1: " + form.cleaned_data['password'] + \
" pass2: " + form.cleaned_data['password2']
user = User.objects.create_user(form.cleaned_data['username'], password=form.cleaned_data['password'])
#Log in user
user2 = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
login(request, user2)
return HttpResponseRedirect('/m/home/')
else:
return render_to_response('login.html', {'form': form}, context_instance=RequestContext(request))
return render_to_response('login.html', {'form': LoginForm()}, context_instance=RequestContext(request))
def user_login(request):
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=form.cleaned_data['username'], password=form.cleaned_data['password'])
if user is not None:
print 'We got to here'
if user.is_active:
login(request, user)
return redirect("/secret")
else:
return 'Invalid Account'
else:
form = LoginForm()
data = {'form': form}
return render(request, "login.html", data)
def login():
if current_user.is_authenticated:
return redirect('/')
form = LoginForm()
if request.method == 'POST':
if form.validate_on_submit():
user = User.query.filter_by(email=request.form['email']).first()
if user is not None and user.verify_password(
request.form['password']):
login_user(user)
return redirect('/')
else:
form.email.errors.append('This account is not found')
else:
flash(form.validate())
return render_template('auth/login.html', form=form)
async def login(request):
session = await get_session(request)
if session.get('user'):
redirect(request, 'main')
form = LoginForm()
if request.method == 'POST':
form.process(await request.post())
if form.validate():
user = User(request.db)
result = await user.authenticate(email=form.email.data,
password=form.password.data)
if result and result.rowcount:
row = await result.fetchone()
session = await get_session(request)
set_session(session, row['id'], request)
redirect(request, 'main')
return {'title': 'Please enter login or email', 'form': form}
async def login(request):
session = await get_session(request)
if session.get('user'):
redirect(request, 'main')
form = LoginForm()
if request.method == 'POST':
form.process(await request.post())
if form.validate():
user = User(request.db)
result = await user.authenticate(email=form.email.data,
password=form.password.data)
if result and result.rowcount:
row = await result.fetchone()
session = await get_session(request)
set_session(session, row['id'], request)
redirect(request, 'main')
return {'title': 'Please enter login or email', 'form': form}
def login():
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(username=form.username.data).first()
if user:
if check_password_hash(user.password, form.password.data):
login_user(user, remember=form.remember.data)
flash(
'Logged in successfully as {}'.format(
current_user.username), 'success')
return render_template(baseTemplate)
flash('Invalid username or password', 'danger')
# return render_template(loginTemplate, form=form, error=True)
return render_template(loginTemplate, form=form)
return render_template(loginTemplate, form=form)
def login_view(request):
if request.method == 'POST':
form = LoginForm(data=request.POST)
if form.is_valid():
username = request.POST['username']
password = request.POST['password']
u = User(username, password)
if (u.connected):
request.session['connected'] = True
request.session['username'] = username
request.session['password'] = password
request.session['trombi'] = u.get_trombi()
request.session['infos'] = u.infos
login_user(request, username, password)
return http.HttpResponseRedirect('/')
else:
form = LoginForm()
return render(request, 'auth/login.html', {'form' : form})
def login(request):
if request.method == "POST":
form = LoginForm(request.POST)
if form.is_valid():
user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password'])
if user is not None and user.is_active:
auth.login(request, user)
messages.success(request, "Welcome, %s.\
Thanks for logging in." % user.username)
return HttpResponseRedirect("/articles/all/")
else:
messages.error(request, "The username and \
password were incorrect.")
return HttpResponseRedirect("/auth/login/")
else:
form = LoginForm()
return render_to_response("auth/login.html", {"form": form},
context_instance=RequestContext(request))
def login_view(request):
form = LoginForm(request.POST or None)
msg = 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:
msg = 'Неверные данные аутентификации'
else:
msg = 'Введите корректные логин и пароль'
return render(request, "accounts/login.html", {"form": form, "msg": msg})
def register():
form = RegistrationForm(request.form)
if form.validate():
if DelhiveryUser.find_user(form.email.data):
form.email.errors.append("Email address already registered")
return render_template('delhivery.html',
loginform=LoginForm(),
registrationform=form)
else:
user = DelhiveryUser(email=form.email.data)
user.first_name = form.first_name.data
user.last_name = form.last_name.data
role = DelhiveryHierarchy.objects.get(role=form.role.data)
user.role = role
user.set_password(form.password.data)
user.save()
flash('Successfully registered', 'success')
return redirect(url_for('auth_views.delhivery_index'))
return render_template("delhivery.html",
loginform=LoginForm(),
registrationform=form)
def login():
form = LoginForm()
if form.validate_on_submit():
email = request.form.get('email')
password = request.form.get('password')
remember = True if request.form.get('remember') else False
user = User.query.filter_by(email=email).first()
# check if user actually exists
# take the user supplied password, hash it, and compare it to the hashed password in database
if not user or not check_password_hash(user.password, password):
flash('Please check your login details and try again.')
return redirect(
url_for('auth.login')
) # if user doesn't exist or password is wrong, reload the page
# if the above check passes, then we know the user has the right credentials
login_user(user, remember=remember)
return redirect(url_for('core.profile'))
return render_template('login.html', form=form)
def login(request):
"""Renders the home/login template"""
error = ''
form = LoginForm(request.POST or None)
if request.method == 'POST' and form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user = auth.authenticate(username=username, password=password)
if user:
auth.login(request, user)
return redirect('user-home')
else:
error = 'Your username or password appear to be incorrect.'
context = {
'form': form,
'error': error,
}
return render(request, 'auth/login.html', context)
def login():
# take in username/password and do db comparison
# return the result
content = request.form
login_form = LoginForm(content)
if login_form.validate():
hashed_password = hashlib.sha256(content['password_login'].encode('utf-8')).hexdigest()
user = user_database.find_one({
'username': content['username_login'],
'password': hashed_password
})
if user:
user['_id'] = str(user['_id'])
session['user'] = user
print(request.remote_addr)
log({
'username': user['username'],
'ip': request.remote_addr,
'message': 'Login at ' + request.remote_addr
})
return jsonify({
'status': 'success',
'hwid': user['hwid'],
'subscribed_until': user['subscribed_until'],
'message': 'Login successful.'
})
return jsonify({
'status': 'error',
'message': 'Invalid credentials.'
})
return jsonify({
'status': 'error',
'message': 'Please fill out the form.'
})
def login_view(request):
logged_in = request.user.is_authenticated()
if not logged_in:
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
usuario = request.POST['usuario']
contrasena = request.POST['contrasena']
usuario = authenticate(username = usuario , password = contrasena)
if usuario is not None:
if usuario.is_active:
login(request , usuario)
return HttpResponseRedirect('/inicio/')
else:
return render(request , 'contacto_formulario.html' , {'subtitulo' : 'Usuario no esta activo' ,'title' : 'Error | Borbolla Metrology' , 'texto': 'El usuario no esta activo , favor de ponerse en contacto con el administrador '})
else:
return render(request , 'contacto_formulario.html' , {'subtitulo' : 'Error de Autentificacion' ,'title' : 'Error | Borbolla Metrology' , 'texto': 'El usuario o contrasena son incorrectos , favor de introducirlos nuevamente'})
else:
form = LoginForm()
return render(request , 'contacto_formulario.html' , {'subtitulo' : 'Formulario de Acceso' ,'form': form ,'title' : 'Login | Borbolla Metrology' , 'texto': 'Ingrese su usuario y contrasena '})
return render(request , 'contacto_formulario.html' , {'subtitulo' : 'Formulario de Acceso' ,'title' : 'Login | Borbolla Metrology' , 'texto': 'Ya estas Autentificado '})
def user_login(request):
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
user = authenticate(username=cd['username'],
password=cd['password'])
if user is not None:
if user.is_active or True:
login(request, user)
return home(request)
else:
return render(request, 'accounts/login.html', {
'form': form,
'error': 'Аккаунт неактивен'
})
else:
return render(request, 'accounts/login.html', {
'form': form,
'error': 'Не верный логин или пароль!'
})
else:
form = LoginForm()
return render(request, 'accounts/login.html', {'form': form})
def login(request):
if request.method == 'POST':
ip = request.META['REMOTE_ADDR']
# check for banned ip
banned = BannedIP.objects.values_list('ip')
if len(banned)>0 and ip in banned[0]:
return HttpResponseRedirect(settings.LOGIN_URL)
# check for more than 3 failed attempts in the last 5 minutes
dt = datetime.now() - timedelta(minutes=5)
if FailedLogin.objects.filter(added__gt=dt).count() > 2:
b = BannedIP()
b.ip = ip
b.save()
return HttpResponseRedirect(settings.LOGIN_URL)
success_redirect = get_safe_url(request.GET['next'], request.get_host()) if request.GET.get('next') else '/'
return process_login(request, success_redirect, settings.LOGIN_URL)
else:
f = LoginForm()
return render_to_response('login.html', {'form':f.as_p()}, context_instance=RequestContext(request))
def process_login(request, success_redirect=None, error_redirect=None, success_response=None):
f = LoginForm(request.POST)
if f.is_valid():
u = auth.authenticate(username=request.POST['username'], password=request.POST['password'])
if u:
if u.is_active:
auth.login(request, u)
if success_redirect:
return HttpResponseRedirect(success_redirect)
elif success_response:
return success_response
else:
return HttpResponse(200)
else:
mail_admins('Inactive user attempted to login', '')
if error_redirect:
return HttpResponseRedirect(error_redirect)
else:
return HttpResponse(status=403)
else:
f = FailedLogin()
f.ip = request.META['REMOTE_ADDR']
f.save()
mail_admins('Failed login attempt', '')
if error_redirect:
return HttpResponseRedirect(error_redirect)
else:
return HttpResponse(status=403)
else:
return False
def test_bad_password(self):
LoginForm.test(
[''], # raises an error to main form
email='*****@*****.**',
pwd='wrong'
)
def test_bad_email(self):
LoginForm.test(
['email'],
email='bademail',
pwd='random'
)
def test_valid(self):
LoginForm.test(
[], save=False,
email='*****@*****.**',
pwd='a'
)
def test_login_form_is_valid():
form = LoginForm({
'username': '******',
'password': '******',
})
assert form.is_valid()
def test_missing_email(self):
LoginForm.test(
[''], # raises an error to main form
email='*****@*****.**',
pwd='random'
)
