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 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 register():
if isadmin == False:
flash('Unauthorized Access!')
return redirect(url_for('user.dashboard'))
form = RegistrationForm()
if form.validate_on_submit():
cursor.execute(
"SELECT department_name FROM department WHERE department_id = %s",
(form.department_id.data, )) # Add to postgres database
department_name = cursor.fetchone()[0]
cursor.execute(
"INSERT INTO employee(employee_id, password, first_name, last_name, email_id, department_id, date_of_joining, isadmin) VALUES(%s, %s, %s, %s, %s, %s, %s, %s)",
(form.username.data, form.password.data, form.first_name.data,
form.last_name.data, form.email.data, form.department_id.data,
'now()', form.isadmin.data))
cursor.execute(
"INSERT INTO leaves_left(employee_id, total_leaves_left, year) VALUES(%s, %s, %s)",
(form.username.data, 30, 2019))
cursor.execute(
"INSERT INTO leaves_left(employee_id, total_leaves_left, year) VALUES(%s, %s, %s)",
(form.username.data, 30, 2020))
cursor.execute(
"INSERT INTO leaves_left(employee_id, total_leaves_left, year) VALUES(%s, %s, %s)",
(form.username.data, 30, 2021))
cursor.execute(
"INSERT INTO leaves_left(employee_id, total_leaves_left, year) VALUES(%s, %s, %s)",
(form.username.data, 30, 2022))
cursor.execute(
"INSERT INTO leaves_left(employee_id, total_leaves_left, year) VALUES(%s, %s, %s)",
(form.username.data, 30, 2023))
emp = { # Add to monodb database
"_id": form.username.data,
"first_name": form.first_name.data,
"last_name": form.last_name.data,
"email_id": form.email.data,
"department_id": department_name,
"no_awards": 0,
"no_publications": 0,
"no_researchs": 0,
"no_projects": 0,
"biography": "",
"education": [],
"experience": [],
"research_interests": [],
"projects": [],
"awards": [],
"publications": []
}
conn.commit()
db.employee.insert_one(emp)
flash('Employee Registered Successfully!')
return redirect(url_for('admin.dashboard'))
return render_template('auth/register.html',
form=form,
title='Register',
isadmin=isadmin,
username=username,
role=role)
def register():
if current_user.is_authenticated:
return redirect(url_for('documents.index'))
form = RegistrationForm()
if form.validate_on_submit():
form.apply()
return redirect(url_for('auth.login'))
return render_template('auth/register.html', title='Register', form=form)
def test_registration_form_is_valid():
form = RegistrationForm({
'email': '*****@*****.**',
'first_name': 'Dan',
'last_name': 'Sackett',
'username': '******',
'password': '******',
'confirm_password': '******',
})
assert form.is_valid()
def test_registration_form_is_not_valid_due_to_confirm_password_missing():
form = RegistrationForm({
'email': '*****@*****.**',
'first_name': 'Dan',
'last_name': 'Sackett',
'username': '******',
'password': '******',
})
assert not form.is_valid()
assert ['confirm_password'] == form.errors.keys()
def signin(request):
args = {}
args.update(csrf(request))
if (request.method == 'POST'):
form = RegistrationForm(request.POST)
args['form'] = form
if form.is_valid():
form.save()
return (HttpResponseRedirect("/"))
else:
args['form'] = RegistrationForm()
return (render_to_response('signin.html', args, context_instance=RequestContext(request)))
def register(request, form_id, email, password, **kwargs):
dajax = Dajax()
clear_form_errors(dajax, form_id)
form = RegistrationForm(data={'email' : email, 'password' : password})
if form.is_valid():
form.save(request = request)
dajax.script("$('#modal').load('%s')" % reverse('auth_confirmation_sent'))
else:
set_form_errors(dajax, form_id, form.errors)
return dajax.json()
def signup():
if current_user.is_authenticated:
return redirect(url_for('home'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(name=form.name.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash('Congratulations, you are now a registered user!')
return redirect(url_for('home'))
return render_template('signup.html', title='Register', form=form)
def register():
if current_user.is_authenticated:
return redirect(url_for('main.index'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash('Parabéns, você se registrou!')
return redirect(url_for('auth.login'))
return render_template('register.html', title='Registro', form=form)
def test_registration_form_creates_user():
form = RegistrationForm({
'email': '*****@*****.**',
'first_name': 'Dan',
'last_name': 'Sackett',
'username': '******',
'password': '******',
'confirm_password': '******',
})
assert form.is_valid()
form.save()
assert len(User.objects.all()) == 1
def POST(self):
f = RegistrationForm()
if not f.validates():
render = web.template.render('templates')
return render.register()
else:
domain_override = web.ctx.host
new_user = f.save(domain_override)
# render = web.template.render('templates')
# web.header('Content-Type', 'text/html')
# return render.register_success()
web.header('Content-Type', 'application/json')
return json.dumps({'success':True})
def register(request):
auth_form = AuthenticationForm()
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = form.save()
d_login(request, new_user)
return HttpResponseRedirect('/')
else:
form = RegistrationForm()
return render_to_response('registration_form.html',
{ 'form': form, 'auth_form': auth_form },
context_instance=RequestContext(request))
def register():
if g.user.is_authenticated:
return redirect(request.args.get('next') or url_for('.user'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username = form.username.data,
email = form.email.data,
password = md5((form.password.data + form.username.data).encode('utf-8')).hexdigest())
db.session.add(user)
db.session.commit()
login_user(user)
return redirect(url_for('.user'))
return render_template('auth/register.html', form=form)
def register():
if current_user.is_authenticated:
return redirect(url_for('main.index'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash(_('Congratulations, you are now a registered user!'))
return redirect(url_for('auth.login'))
return render_template('auth/register.html',
title=_('Register'),
form=form)
def register(request):
""" Registers a member """
form = RegistrationForm()
if request.method == 'POST':
data = request.POST
form = RegistrationForm(data)
if form.is_valid():
user = form.save(request) #profile_callback=Member.objects.profile_callback)
return HttpResponseRedirect(reverse('register_success'))
return render_to_response('auth/register.html', {
'form': form,
}, RequestContext(request))
def signin(request):
if request.user.is_authenticated():
return HttpResponseRedirect("/", {"user": request.user})
args = {}
args.update(csrf(request))
args["title"] = "Sign In"
if request.method == "POST":
form = RegistrationForm(request.POST)
args["form"] = form
if form.is_valid():
form.save()
return HttpResponseRedirect("/")
else:
args["form"] = RegistrationForm()
return render_to_response("form.html", args, context_instance=RequestContext(request))
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 register(request):
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(form.cleaned_data['username'],
form.cleaned_data['email'],
form.cleaned_data['password'])
user.first_name = form.cleaned_data['first_name']
user.last_name = form.cleaned_data['last_name']
user.save()
messages.success(request, "Success register. Let,s login.")
return HttpResponseRedirec("/tauth/login/")
else:
form = RegistrationForm()
return render_to_response("auth/register.html", {"form": form},
context_instance=RequestContext(request))
def register(request):
c = {}
c.update(csrf(request))
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password1')
newuser = User.objects.create_user(username=username, email='', password=password)
if form.cleaned_data.get('email'):
newuser.email = form.cleaned_data.get('email')
EmailValidation.objects.add(user=newuser, email=newuser.email)
newuser.save()
return HttpResponseRedirect('%scomplete/' % request.path_info)
else:
form = RegistrationForm()
template = "userprofile/account/registration.html"
data = { 'form': form }
return render_to_response(template, data, context_instance=RequestContext(request))
def register(request):
"""Allow a user to register for the site"""
form = RegistrationForm(request.POST or None)
if request.method == 'POST' and form.is_valid():
form.save()
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')
return redirect('login')
context = {
'form': form,
}
return render(request, 'auth/register.html', context)
def post(self, request, user, feed):
register_form = None
register_user = None
subscribe_form = PaymentForm(request.POST)
if self.request.user.is_anonymous():
register_form = RegistrationForm(request.POST)
if ((register_form and register_form.is_valid()) or register_form == None) and subscribe_form.is_valid():
if register_form:
register_user = register_form.save(request)
register_user.profile.status = 'REG'
register_user.profile.save()
registed_user = authenticate(
username=request.POST.get('username'),
password=request.POST.get('password')
)
FeedSubscriber.objects.get_or_create(feed=feed, user=register_user or request.user)
if request.is_ajax():
response = {
'error': subscribe_form.errors,
'success_url': reverse('feed_detail', args=[
feed.publisher.username,
feed.slug
])
}
if register_form:
response['error'].update(register_form.errors)
status = 200
if response['error']:
status = 400
return HttpResponse(json.dumps(response), status=status, mimetype="application/json")
return self.render(user, feed, register_form, subscribe_form)
def signup(request):
if request.method == 'POST':
user_form = RegistrationForm(request.POST)
if user_form.is_valid():
user_form.save()
return render(request, 'accounts/signup_finish.html',
{'form': user_form})
else:
user_form = RegistrationForm()
return render(request, 'accounts/signup.html', {'form': user_form})
def register(request):
if request.method == 'GET':
form = RegistrationForm()
elif request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = get_user_model()
user = user()
user.username = form.cleaned_data.get('username')
user.email = form.cleaned_data.get('email')
user.password = make_password(form.cleaned_data.get('password'))
user.is_active = False
user.reset_activation_token()
user.generate_verification_token()
user.save()
return redirect("%s?message=%s" %
(reverse('message'), REG_SUCCESSFUL))
else:
return HttpResponseNotAllowed(permitted_methods=['POST', 'GET'])
return render(request, 'registration/register.html', {'form': form})
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 register(request):
if request.method == 'GET':
form = RegistrationForm()
elif request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = get_user_model()
user = user()
user.username = form.cleaned_data.get('username')
user.email = form.cleaned_data.get('email')
user.password = make_password(form.cleaned_data.get('password'))
user.is_active = False
user.reset_activation_token()
user.generate_verification_token()
user.save()
return redirect("%s?message=%s" %
(reverse('message'), REG_SUCCESSFUL))
else:
return HttpResponseNotAllowed(permitted_methods=['POST', 'GET'])
return render(request, 'registration/register.html', {'form':form})
def user_register(**kwargs):
form = RegistrationForm(csrf_enabled=False)
if form.validate_on_submit():
username = form.username.data
emails = form.email.data
password = form.password.data
user = User.query.filter_by(username=username).first()
if user is None:
db = get_db()
user_tmp = User(username=username, email=emails)
user_tmp.password = password
db.session.add(user_tmp)
db.session.commit()
login_user(user_tmp)
session["known"] = False
else:
session["known"] = True
session["name"] = username
session["email"] = emails
return dict(success=1)
else:
return dict(fail=1)
def register_user(request):
state = "Please fill in all of the blanks below..."
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid(): # add user existing check, password same check
username = form.cleaned_data["username"]
password = form.cleaned_data["password"]
email = form.cleaned_data["email"]
new_user = User.objects.create_user(username, email, password)
new_s_user = SherlockUser.objects.create_SherlockUser(new_user)
new_user.save()
new_s_user.save()
user = authenticate(username=username, password=password)
login(request, user)
return HttpResponseRedirect("/home/")
else:
form = RegistrationForm()
return render(request, "register.html", {"form": form})
def register(request):
c = {}
c.update(csrf(request))
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password1')
newuser = User.objects.create_user(username=username,
email='',
password=password)
if form.cleaned_data.get('email'):
newuser.email = form.cleaned_data.get('email')
EmailValidation.objects.add(user=newuser, email=newuser.email)
newuser.save()
return HttpResponseRedirect('%scomplete/' % request.path_info)
else:
form = RegistrationForm()
template = "userprofile/account/registration.html"
data = {'form': form}
return render_to_response(template,
data,
context_instance=RequestContext(request))
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('/accounts/login/')
else:
return render(request, 'registration/reg_form.html',
{'form': form})
else:
form = RegistrationForm()
return render(request, 'registration/reg_form.html', {'form': form})
def test_registration_form_is_not_valid_due_to_username_being_taken():
# setup user
user = User(
username='******',
first_name='First Name',
last_name='Last Name',
email='*****@*****.**',
is_active=True,
is_staff=False,
date_joined=datetime.datetime.now(),
)
user.set_password('P@ssw0rd!')
user.save()
form = RegistrationForm({
'email': '*****@*****.**',
'first_name': 'Dan',
'last_name': 'Sackett',
'username': '******',
'password': '******',
'confirm_password': '******',
})
assert not form.is_valid()
assert ['username'] == form.errors.keys()
def register_user(request):
state = "Please fill in all of the blanks below..."
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():#add user existing check, password same check
username = form.cleaned_data['username']
password = form.cleaned_data['password']
email = form.cleaned_data['email']
new_user = User.objects.create_user(username, email, password)
new_s_user = DDAUser.objects.create_DDAUser(new_user)
new_user.save()
new_s_user.save()
user = authenticate(username=username, password=password)
login(request, user)
return HttpResponseRedirect('/home/')
else:
form = RegistrationForm()
return render(request, 'register.html', {
'form': form,
})
def signup(request):
username = None
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data['username']
form = None
else:
form = RegistrationForm()
context = {'form': form, 'username': username}
return render(request, 'signup.html', context)
def signin(request):
args = {}
args.update(csrf(request))
if (request.method == 'POST'):
form = RegistrationForm(request.POST)
args['form'] = form
if form.is_valid():
form.save()
return (HttpResponseRedirect("/"))
else:
args['form'] = RegistrationForm()
return (render_to_response('signin.html',
args,
context_instance=RequestContext(request)))
async def post(self):
form = RegistrationForm(self.request.arguments)
if form.validate():
usr = form.get_object()
usr.set_password(usr.password)
try:
await usr.insert(self.db)
except DuplicateKeyError:
form.set_field_error('email', 'email_occupied')
else:
# user save succeeded
self.set_current_user(usr.email)
self.post_success()
return
self.post_failed(form)
def signin(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/', {"user": request.user})
args = {}
args.update(csrf(request))
args['title'] = "Sign In"
if (request.method == 'POST'):
form = RegistrationForm(request.POST)
args['form'] = form
if form.is_valid():
form.save()
return (HttpResponseRedirect("/"))
else:
args['form'] = RegistrationForm()
return (render_to_response('form.html',
args,
context_instance=RequestContext(request)))
async def update_context(self):
form = RegistrationForm()
self.add_additional_context({'form': form})
def delhivery_index():
if current_user.is_authenticated:
return redirect(url_for('delhivery_views.index'))
return render_template("delhivery.html",
loginform=LoginForm(),
registrationform=RegistrationForm())
