def register(request):
if request.method == 'POST':
user_form = RegistrationForm(request.POST)
if user_form.is_valid():
username = user_form.cleaned_data.get('username')
email = user_form.cleaned_data.get('email')
password = user_form.cleaned_data.get('password')
User.objects.create_user(
username=username,
email=email,
password=password,
)
user = authenticate(username=username, password=password)
login(request, user)
_success_msg = 'User {0} added'.format(user.username)
feed = Feed(user=user, posts=_success_msg)
feed.save()
return redirect('/feeds/')
else:
return render(request, 'authentication/register.html',
{'form': user_form})
else:
user_form = RegistrationForm()
return render(request, 'authentication/register.html', {'form': user_form})
def register_view(request, *args, **kwargs):
if request.method == "GET":
context = {
'user_form': RegistrationForm(),
'profile_form': ProfileForm(),
}
return render(request, 'auth/register.html', context)
elif request.method == 'POST':
user_form = RegistrationForm(request.POST)
profile_form = ProfileForm(request.POST, request.FILES)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
login(request, user)
return redirect('home view')
context = {
'user_form': RegistrationForm(),
'profile_form': ProfileForm(),
}
return render(request, 'auth/register.html', context)
def register(request, *args, **kwargs):
if request.method == 'POST':
registration_form = RegistrationForm(request.POST)
if registration_form.is_valid():
registration_form.save()
return redirect('/login/')
else:
registration_form = RegistrationForm()
return render(request, 'authentication/registration.html',
{'form': registration_form})
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("/applist"))
else:
args['form'] = RegistrationForm()
return (render_to_response('signin.html',
args,
context_instance=RequestContext(request)))
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('home'))
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'registration/signup.html', args)
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'registration/signup.html', args)
def test_registration_form_matching_passwords(self):
"""
Test that ``RegistrationForm`` has matching passwords
"""
form_data = RegistrationFormTest.form_data_dict[2]
form = RegistrationForm(data=form_data['data'])
self.assert_(not form.is_valid())
def register(request):
if request.method == 'POST':
user_form = RegistrationForm(request.POST)
if user_form.is_valid():
user = user_form.save()
login(request, user)
messages.success(request, 'Your profile was created successfully!')
return redirect('details', pk=user.pk)
else:
user_form = RegistrationForm(request.POST)
messages.warning(request, 'Correct the errors bellow.')
return render(request, template_name='register.html', context={'user_form': user_form})
elif request.method == 'GET':
user_form = RegistrationForm()
return render(request, template_name='register.html', context={'user_form': user_form})
def test_registration_form_valid_username_syntax(self):
"""
Test that ``RegistrationForm`` enforces username syntax constraints
"""
form_data = RegistrationFormTest.form_data_dict[0]
form = RegistrationForm(data=form_data['data'])
self.assert_(not form.is_valid())
def register(request):
"""
Sign up a user
:param request:
:return:
"""
if request.method == "POST":
form = RegistrationForm(request.POST)
phone = request.POST.get("phone")
if form.is_valid():
user = form.save(commit=False)
user.email = form.cleaned_data.get("username")
user.set_password(form.cleaned_data.get("password1"))
user.is_active = False
user.save()
profile = Profile.objects.create(user=user, telephone_number=phone)
profile.save()
url_name = "authentication:activate_user"
activation_link = generate_activation_url(request, user, url_name)
message_body = constants.ACCOUNT_ACTIVATION_MESSAGE.format(
activation_link=activation_link)
mailing_list = [user.email]
send_mail("FreshCollections", message_body,
"*****@*****.**", mailing_list)
user.backend = "authentication.backend.EmailAuthBackend"
_login(
request,
user) # , backend="authentication.backend.EmailAuthBackend")
next_url = request.GET.get("next")
return redirect("authentication:registration_success")
else:
import pdb
pdb.set_trace()
return redirect("authentication:auth_get")
def register_user_view(request):
logger.debug("register_user_view called by user %s" % request.user)
if request.method == 'POST':
form = RegistrationForm(request.POST)
logger.debug("Request type POST contains form valid: %s" %
form.is_valid())
if form.is_valid():
if not User.objects.filter(
username=form.cleaned_data['username']).exists():
user = User.objects.create_user(form.cleaned_data['username'],
form.cleaned_data['email'],
form.cleaned_data['password'])
user.save()
logger.info("Created new user %s" % user)
login(request, user)
messages.warning(request,
_('Add an API key to set up your account.'))
return redirect("auth_dashboard")
else:
logger.error(
"Unable to register new user: username %s already exists."
% form.cleaned_data['username'])
return render(request,
'public/register.html',
context={
'form': form,
'error': True
})
else:
logger.debug(
"Registration form invalid. Returning for user %s to make corrections."
% request.user)
else:
logger.debug("Returning blank registration form.")
form = RegistrationForm()
return render(request, 'public/register.html', context={'form': form})
def test_registration_form_valid_existing_username(self):
"""
Test that ``RegistrationForm`` enforces username length constraints
"""
self.user = User.objects.create(
username='******',
password='******',
email='*****@*****.**',
)
form_data = RegistrationFormTest.form_data_dict[1]
form = RegistrationForm(data=form_data['data'])
self.assert_(not form.is_valid())
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST, request.FILES)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password1')
acc_type = form.cleaned_data.get('account_type')
user = authenticate(username=username, password=password)
acc = Account(user=user,
account_type=acc_type,
user_id=user.id,
id=user.id)
if form.cleaned_data['avatar'] is not None:
acc.avatar = form.cleaned_data['avatar']
acc.save()
login(request, user)
return HttpResponseRedirect(
'/accounts/profile/') #redirect path after login here
else:
form = RegistrationForm()
return render(request, 'registration.html', {'form': form})
def register(request):
#if request.user.is_authenticated():
# They already have an account; don't let them register again
# return render_to_response('core/register.html', {'has_account': True})
if request.method == 'GET':
c = {}
c.update(csrf(request))
c['form'] = RegistrationForm()
return render_to_response('authentication/register.html', c)
if not request.method == 'POST': return HttpResponseRedirect('/')
registrationForm = RegistrationForm(request.POST)
if registrationForm.is_valid():
user = registrationForm.save(commit=False)
user.is_active = False
user.save()
profile = UserProfile(
user=user,
activation_key=hashlib.sha224(user.username).hexdigest()[:40],
key_expires=datetime.datetime.today() + datetime.timedelta(days=2))
profile.save()
host = request.META['SERVER_NAME']
email_subject = 'Welcome!'
email_body = """Thanks for signing up. To activate your account, follow this link: http://%(host)s/accounts/confirm/%(hash)s"""
email_body = email_body % {
'host': host,
'hash': profile.activation_key
}
send_mail(email_subject, email_body, 'account_creator@' + host,
[user.email])
return render_to_response('authentication/register.html',
{'created': True})
c = {}
c.update(csrf(request))
c['form'] = registrationForm
return render_to_response('authentication/register.html', c)
def home(request):
"""
Return the landing page of the app
:param request:
:return:
"""
template = "index.html"
login_form = LoginForm()
registration_form = RegistrationForm()
context = {
"login_form": login_form,
"registration_form": registration_form
}
return render(request, template, context)
def register_view(request):
if request.method == 'POST':
form = RegistrationForm(request.POST, request.FILES)
if form.is_valid():
# TODO: hash password!
# form.save()
user = Profile.objects.create_user(
username=form.data.get('username', ''),
email=form.data.get('email', ''),
password=form.data.get('password', ''),
profile_picture_url=request.FILES['profile_picture_url'])
user.save()
# return HttpResponse('ok')
# import ipdb; ipdb.set_trace()# BREAKPOINT)
return HttpResponseRedirect(reverse('login'))
# If form is not valid post errors
status_message = 'Something went wrong while registering you!'
form = RegistrationForm()
return render(request, 'registration/registration_form.html', locals())
def auth_get(request):
"""
Returns the template for user authentication (login/registration) - auth.html
:param request:
:return:
"""
template = "authentication/auth.html"
login_form = LoginForm()
registration_form = RegistrationForm()
context = {
"login_form": login_form,
"registration_form": registration_form
}
return render(request, template, context)
def database_check(response):
form = RegistrationForm(response.POST)
if form.is_valid():
email = form.cleaned_data["email"]
has_email = database(
'db.sqlite3', "SELECT email FROM User WHERE email = ?;", (email,))
logged_in = None
if has_email:
logged_in = database(
'db.sqlite3', "SELECT logged_in FROM User WHERE email = ?;", (email,))
if not logged_in:
return redirect('authentication:login')
else:
response.session['email'] = email
return redirect('authentication:register')
def register(request):
"""
Register a new user onto the platform
"""
#pylint: disable=unused-variable
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = User.objects.create_user(
username=form.cleaned_data['username'],
password=form.cleaned_data['password1'],
email=form.cleaned_data['email'],
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
)
return HttpResponseRedirect('/register/success/')
else:
form = RegistrationForm()
variables = RequestContext(request, {'form': form})
return render_to_response(
'registration/register.html',
variables,
)
def Authenticate_1(request,
success_url=None,
login_form=LoginForm,
form_class=RegistrationForm,
template_name='index.html',
extra_context=None,
**kwargs):
if request.method == 'POST':
if "confirmsignin" in request.POST:
form_auth = login_form(data=request.POST)
if form_auth.is_valid():
username = form_auth.cleaned_data['username']
password = form_auth.cleaned_data['password']
launchers = authenticate(username=username, password=password)
if launchers is not None:
login(request, launchers)
return HttpResponseRedirect('/Launch2Lead/')
else:
return render_to_response('Launch2Lead/index.html', {'form_auth': form_auth},
context_instance=RequestContext(request))
if "confirmsignup" in request.POST:
form = form_class(data=request.POST)
if form.is_valid():
user = User.objects.create_user(username=form.cleaned_data['username'], email=form.cleaned_data['email'],
password=form.cleaned_data['password'])
user.save()
launchers = UserProfile.objects.get_or_create(user=user, email=form.cleaned_data['email'])[0]
launchers.save()
return render_to_response('Launch2Lead/index.html', {'form': form},
context_instance=RequestContext(request))
return render_to_response('Launch2Lead/index.html', {'Login',login_form, 'Register', form_class})
else:
form = RegistrationForm()
form_auth = LoginForm()
return render_to_response('Launch2Lead/index.html', {'form': form, 'form_auth': form_auth}, context_instance=RequestContext(request))
def register():
if current_user.firm == "Collibri":
form = RegistrationForm()
if form.validate_on_submit():
hashed_pw = bcrypt.generate_password_hash(
form.password.data).decode("utf-8")
user = User(
username=form.username.data,
email=form.email.data,
password=hashed_pw,
firm=form.firm.data,
function=form.function.data,
)
db.session.add(user)
db.session.commit()
flash("The account has been created! You are now able to log in.",
"succes")
return redirect(url_for("arcticsun_index", device_type="arctic"))
return render_template("authentication/register.html",
title="Register",
form=form)
def test_registration_form_email(self):
form = RegistrationForm(data={"email": ''})
self.assertFalse(form.is_valid())
self.assertEqual(form.errors["email"], ["This field is required."])