def registration_view(request):
context = {}
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
email = form.cleaned_data.get('email')
raw_password = form.cleaned_data.get('password1')
username = form.cleaned_data.get('username')
employee = form.cleaned_data.get('employee')
account = authenticate(email=email,
password=raw_password,
username=username,
employee=employee)
login(request, account)
return redirect('/')
else:
context['registration_form'] = form
else:
form = RegistrationForm()
# context['registration_form'] = form
context = {'registration_form': form}
return render(request, 'accounts/user_register.html', context)
class RegisterView(TemplateView):
template_name = "register.html"
def __init__(self):
super(RegisterView, self).__init__()
self.form = RegistrationForm()
def get_context(self, request, *args, **kwargs):
context = {'form': self.form}
return context
def get(self, request, *args, **kwargs):
return self.render_to_response(self.get_context(request))
def post(self, request, *args, **kwargs):
self.form = RegistrationForm(request.POST)
if self.form.is_valid():
self.form.save()
user = auth.authenticate(username=self.form.user.email,
password=self.form.str_password)
auth.login(request, user)
send([user], 'registration')
return HttpResponseRedirect("/accounts/personal-data-master/")
return self.render_to_response(self.get_context(request))
def registration_view(request):
context = {}
redirect_to = request.GET.get('next', '')
if redirect_to != "" or redirect_to is not None:
context['redirect_to'] = redirect_to
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
customer_number = form.cleaned_data.get('mobile')
# print(customer_number)
# user_otp = form.cleaned_data.get('otp')
# print(user_otp)
# send_otp(customer_number,user_otp)
form.save()
email = form.cleaned_data.get('email')
raw_password = form.cleaned_data.get('password1')
account = authenticate(email=email, password=raw_password)
login(request, account)
return redirect('home')
else:
context['registration_form'] = form
else: #GET request
form = RegistrationForm()
context['registration_form'] = form
return render(request, 'accounts/register.html', context)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
email = form.cleaned_data['email']
name = form.cleaned_data['first_name'] + " " + form.cleaned_data[
'last_name']
subject = "Welcome to location alarm"
message = "Thank you for registering " + name
from_email = settings.EMAIL_HOST_USER
#to_list=['*****@*****.**']
to_list = [email]
send_mail(subject,
message,
from_email,
to_list,
fail_silently=False)
return redirect('./login')
else:
form = RegistrationForm()
return render(request, 'accounts/signup.html', {'form': form})
def registration_view(request):
context = {}
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password1')
account = authenticate(username=username, password=raw_password)
login(request, account)
if form.cleaned_data.get(
'user_type') == 'Student' or form.cleaned_data.get(
'user_type') == 'student':
return redirect(reverse('profile_info:student-profile'))
elif form.cleaned_data.get(
'user_type') == 'Teacher' or form.cleaned_data.get(
'user_type') == 'teacher':
return redirect(reverse('profile_info:tutor-profile'))
else:
context['registration_form'] = form
else:
form = RegistrationForm()
context['registration_form'] = form
return render(request, 'accounts/register.html', context)
def register(request):
User = get_user_model()
if request.method == 'POST':
register_form = RegistrationForm(request.POST)
# NEW CODE STARTS HERE
if register_form.is_valid():
#1 create the user
register_form.save()
#2 check if the user has been created properly
user = auth.authenticate(username=request.POST['username'],
password=request.POST['password1'])
if user:
#3 if the user has been created successful, attempt to login
auth.login(user=user, request=request)
messages.success(request, "You have successfully registered")
else:
messages.error(request,
"Unable to register your account at this time")
return redirect(reverse('profile'))
#NEW CODE ENDS HERE
else:
return render(request, 'register.html', {'form': register_form})
else:
register_form = RegistrationForm()
return render(request, 'register.html', {'form': register_form})
def register(request):
context = {}
if request.method == "POST":
# Añadimos los datos recibidos al formulario
form = RegistrationForm(data=request.POST)
# Si el formulario es válido...
if form.is_valid():
# Creamos la nueva cuenta de usuario
form.save()
email = form.cleaned_data.get('email')
raw_password = form.cleaned_data.get('password1')
account = authenticate(email=email, password=raw_password)
do_login(request, account)
return redirect('dashboard')
else:
context = {'form': form}
else:
form = RegistrationForm()
context = {'form': form}
# Si queremos borramos los campos de ayuda
#form.fields['username'].help_text = None
form.fields['email'].help_text = None
form.fields['password1'].help_text = None
form.fields['password2'].help_text = None
# Si llegamos al final renderizamos el formulario
return render(request, "register.html", context)
def register_view(request, *args, **kwargs):
template_name = 'accounts/register.html'
user = request.user
if user.is_authenticated:
return HttpResponse(f"You are already authenticated as {user.email}.")
context = {}
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
# after registerration user will automatic login
email = form.cleaned_data.get('email').lower()
raw_password = form.cleaned_data.get('password1')
account = authenticate(email=email, password=raw_password)
login(request, account)
destination = get_redirect_if_exists(request)
if destination:
return redirect(destination)
return redirect("home")
else:
context['registration_form'] = form
return render(request, template_name, context)
def register(request):
"""
A view allowing users to register and shows
messages if form is completed successfully or not
"""
if request.user.is_authenticated:
return redirect(reverse('index'))
if request.method == "POST":
registration_form = RegistrationForm(request.POST)
if registration_form.is_valid():
registration_form.save()
user = auth.authenticate(username=request.POST['username'],
password=request.POST['password1'])
if user:
auth.login(user=user, request=request)
messages.success(request,
"Great job! You've successfully registered")
else:
messages.error(request,
"We are unable to register your account")
else:
registration_form = RegistrationForm()
return render(request, 'registration.html',
{"registration_form": registration_form})
def register(request):
if request.method =='POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
messages.success(request,
'Success!',
'alert alert-success alert-dismissible')
return redirect('website:index')
else:
messages.warning(request,
'Please fix the following errors: ' + str(form.errors),
'alert alert-warning alert-dismissible')
context = {
'form': form,
}
return render(request, 'registration/reg_form.html', context)
else:
form = RegistrationForm()
context = {
'form': form,
}
return render(request, 'registration/reg_form.html', context)
def registration(request):
# context = {}
# if request.POST:
# form = RegistrationForm(request.POST)
# if form.is_valid():
# form.save()
# email = form.cleaned_data.get('email')
# raw_password = form.cleaned_data.get('password1')
# accounts = authenticate(email=email, password= password1)
# login(request, accounts)
# return redirect('home')
# else:
# context['registration_form'] = form
# else: # GET request
# form = RegistrationForm()
# context = {"form": form}
form = RegistrationForm()
if request.method == "POST":
print('form valid ------')
form = RegistrationForm(request.POST)
try:
if form.is_valid():
form.save()
return redirect('home')
else:
print('form not valid 2------')
except ValueError:
print('form not valid ------')
return redirect('register')
context = {'form': form}
return render(request, 'accounts/register.html', context)
def registration(request):
"""
Registration method
"""
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
# register user
form.save()
new_user = authenticate(username=form.cleaned_data['username'],
password=form.cleaned_data['password1'])
# send account creation confirmation email
subject = "Thanks for signing up, %s!" % new_user.first_name
from_email = '*****@*****.**'
to = new_user.email
html_content = render_to_string(
'email_welcome.html', {'user': new_user}
)
text_content = strip_tags(html_content)
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()
# log user in
login(request, new_user)
return redirect('/sign-up/more-details/')
else:
form = RegistrationForm()
return render(request, 'auth_form.html', {'form': form})
class RegisterView(TemplateView):
template_name = "register.html"
def __init__(self):
super(RegisterView, self).__init__()
self.form = RegistrationForm()
def get_context(self, request, *args, **kwargs):
context = {
'form': self.form
}
return context
def get(self, request, *args, **kwargs):
return self.render_to_response(self.get_context(request))
def post(self, request, *args, **kwargs):
self.form = RegistrationForm(request.POST)
if self.form.is_valid():
self.form.save()
user = auth.authenticate(username=self.form.user.email, password=self.form.str_password)
auth.login(request, user)
send([user], 'registration')
return HttpResponseRedirect("/accounts/personal-data-master/")
return self.render_to_response(self.get_context(request))
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
if User.objects.filter(
email=form.cleaned_data.get('email')).exists():
args = {
'error': 'User already exists',
'erlink': '/account/register'
}
return render(request, 'accounts/regerror.html', args)
else:
form.save()
return redirect('/account')
else:
args = {
'error': 'Password not strong',
'erlink': '/account/register'
}
return render(request, 'accounts/regerror.html', args)
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'accounts/reg_form.html', args)
def post(self, request):
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('accounts:login'))
else:
return render(request, 'accounts/register.html', {'form': form})
def post(self, request):
form = RegistrationForm(request.POST)
if form.is_valid(): #override is_valid later for more restriction
form.save()
return redirect(reverse('accounts:login'))
else:
return redirect(reverse('accounts:register')) #deal with fail cases here
def register(request):
form = RegistrationForm(request.POST or None)
if request.method == "POST":
if form.is_valid():
form.save()
return redirect('/login')
context = {'form': form}
return render(request, 'front/register.html', context)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('/accounts/view-profile/')
else:
form = RegistrationForm()
return render(request, 'accounts/register.html', {'form': form})
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('accounts:home'))
else:
form = RegistrationForm
return render(request, 'accounts/register.html', {'form': form})
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('/account/login')
form = RegistrationForm()
args = {"form": form}
return render(request, 'accounts/reg_form.html', args)
def register(request):
if request.method == "POST":
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('accounts:login_url')
else:
form = RegistrationForm()
return render(request, 'accounts/register.html', {'form': form})
def test_form_fails_on_national_id_duplicate(self):
user = User.objects.create(username=USERNAME,
email=EMAIL,
password=PASSWORD)
natid = NationalId.objects.create(id_number=ID_NUMBER, user=user)
form = RegistrationForm(data=TEST_DATA)
form.save()
self.assertTrue(
form.has_error('national_id_number', 'national_id_exists'))
def register(request):
form = RegistrationForm()
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
messages.success(request,'Account has been created !')
return redirect('login')
return render(request,'accounts/register.html',{'form':form})
def register(request):
if request.method == 'POST':
register_form = RegistrationForm(request.POST )
if register_form.is_valid():
register_form.save()
return redirect('/')
else:
register_form = RegistrationForm()
context = {'register_form': register_form}
return render(request, 'register_form.html', context)
def register_page(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('login')
else:
form = RegistrationForm()
context = {'form': form}
return render(request, 'signup.html', context)
def register(request, *args, **kwargs):
form = RegistrationForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
form.save()
return HttpResponseRedirect('/')
# else:
# form = RegistrationForm()
context = {'form': form}
return render(request, 'accounts/reg_form.html', context)
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST) # UserCreationForm
if form.is_valid():
form.save()
return redirect('home')
else:
form = RegistrationForm() #
args = {'form': form}
return render(request, 'accounts/reg_form.html', args)
def register(request):
if request.method == 'GET':
form = RegistrationForm()
args = {'form': form}
return render(request, 'accounts/register.html', args)
else:
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('/account/profile')
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
#return HttpResponseRedirect('/account/home')
return redirect('/account')
else:
form = RegistrationForm()
return render(request, 'accounts/reg_form.html', {'form': form})
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
form.save()
return (redirect('/accounts'))
else:
form = RegistrationForm()
args = {'form': form}
return render(request, 'templates/signup.html', args)
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, 'reg_form.html', args)
def create_user(request):
form = RegistrationForm(request.POST or None)
if request.method == "POST" and form.is_valid():
form.save()
user = authenticate(username=form.cleaned_data["username"],
password=form.cleaned_data["password1"])
login(request, user)
return redirect("accounts:profile")
return render(request, "accounts/create.html", {
"form": form,
})
def register(self, request, **kwargs):
"""
Create and immediately log in a new user.
"""
invitation_key = kwargs.get('invitation_key', None)
email = kwargs.get('email', None)
if request.POST:
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.email = email # email was omitted from form - it's required to use the same email invitation was sent to
user.save() # default groups and all pending accesses are automatically assigned - signal
else:
return None
#username, email, password = kwargs['username'], kwargs['email'], kwargs['password1']
#User.objects.create_user(username, email, password)
# authenticate() always has to be called before login(), and
# will return the user we just created.
new_user = authenticate(username=user.username, password=form.cleaned_data['password1'])
login(request, new_user)
signals.user_registered.send(sender=self.__class__,
user=new_user,
invitation_key=invitation_key,
request=request)
return new_user
def register(request):
code = ""
if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
email = request.POST['email']
form = RegistrationForm(request.POST)
if form.is_valid():
salt = sha.new(str(random.random())).hexdigest()[:5]
activation_code = sha.new(salt+username).hexdigest()
key_expires = datetime.datetime.today() + datetime.timedelta(7)
user = User.objects.create_user(username=username, email=email, password=password)
user.is_active = False
user.save()
profile = form.save(commit=False)
profile.user = user
profile.activation_code = activation_code
profile.key_expires = key_expires
profile.save()
return render_to_response('accounts/register.html',
{'code':activation_code, 'profile':profile}, context_instance=RequestContext(request))
else:
salt = sha.new(str(random.random())).hexdigest()[:5]
activation_code = sha.new(salt+username).hexdigest()
return render_to_response('accounts/register.html',
{'form':form, 'code':activation_code}, context_instance=RequestContext(request))
else:
form = RegistrationForm()
return render_to_response('accounts/register.html',{'form':form, 'code':code})
def login(request):
login_form = LoginForm()
register_form = RegistrationForm()
next = request.REQUEST.get('next', settings.LOGIN_REDIRECT_URL)
# Special case next urls that will lead us into redirect loops
if next == settings.LOGIN_URL:
next = settings.LOGIN_REDIRECT_URL
if 'kind' in request.POST:
if request.POST['kind'] == 'register':
register_form = RegistrationForm(request.POST)
if register_form.is_valid():
_backend_hackend(request, register_form.save())
return HttpResponseRedirect(next)
elif request.POST['kind'] == 'login':
login_form = LoginForm(request.POST)
if login_form.is_valid() and login_form.user:
_backend_hackend(request, login_form.user)
return HttpResponseRedirect(next)
context = {
'login_form': login_form,
'register_form': register_form,
'next': next,
}
return render_to_response('accounts/login.html', context,
context_instance=RequestContext(request))
def register(request):
if request.method == 'POST':
form = RegistrationForm(data=request.POST)
if form.is_valid():
user = form.save()
return redirect('/accounts/register_success')
else:
form = RegistrationForm()
return render(request,'accounts/register.html', {'form':form,})
def register(request):
next_url = request.GET.get('next', None)
if request.method == 'GET':
form = RegistrationForm()
return render(request, 'registration/registration_page.html', {'registration_form': form})
if request.method == 'POST':
# create a form instance and populate it with data from the request
form = RegistrationForm(request.POST, )
if form.is_valid():
client = request.session['client']
new_user = form.save(commit=False)
try: # create a user on the API
data = client.create_user(new_user.email, request.POST['password1'],
new_user.first_name, new_user.last_name,
new_user.phone_number)
new_user.booker_id = data.get('CustomerID', None)
if not new_user.booker_id:
raise ValidationError(data['ErrorMessage'],
code=data['ErrorCode'])
new_user.save()
except ValidationError as error:
form.add_error(None, error)
return render(request, 'registration/registration_page.html',
{'registration_form': form})
# login to the api
client.login(new_user.email, request.POST['password1'])
# authenticate and login the user locally
new_user = authenticate(email=request.POST['email'].lower(),
password=request.POST['password1'])
auth_login(request, new_user)
try:
request.cart.replace(request.session.get('CART-ID'), new_user)
except CartDoesNotExist:
pass
# store the user password for the length of the session
client.user = new_user
messages.info(request, 'Thanks for registering. You are now logged in.')
# redirect user the profile page
if next_url:
return HttpResponseRedirect(next_url)
return HttpResponseRedirect(reverse('welcome'))
return render(request, 'registration/registration_page.html',
{'registration_form': form, 'next': next_url})
def create_user(request):
if not request.user.is_authenticated():
form = RegistrationForm(request.POST or None)
if request.method == "POST" and form.is_valid():
form.save()
user = authenticate(username=form.cleaned_data["username"],
password=form.cleaned_data["password1"])
login(request, user)
comando = "cd templates/assets/img; mkdir %s" % user.username
os.system(comando)
comando = "cd media/photos ;zip %s.zip readme.txr" % user.username
os.system(comando)
return HttpResponseRedirect("/slides/")
else:
return HttpResponseRedirect("/slides/")
return render(request, "registration/create_user.html", {
"form": form,
})
def register_user(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
obj = form.save()
return HttpResponse('<meta http-equiv="refresh" content="1;url=/"/>Registration was successfull')
args = {}
args.update(csrf(request))
args['form'] = RegistrationForm()
return render_to_response('register.html', args)
def registration(request):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse("accounts-home"))
if request.method == "POST":
form = RegistrationForm(request, request.POST)
if form.is_valid():
user = form.save()
send_activation(user)
return render(request, "accounts/registration_done.html")
else:
form = RegistrationForm(request)
return render(request, "accounts/registration.html", {"form": form})
def registration(request):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse('accounts-home'))
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save()
send_activation(user)
return render(request, 'accounts/registration_done.html')
else:
form = RegistrationForm()
return render(request, 'accounts/registration.html', {'form': form})
def register(request):
registration_form = RegistrationForm(request.POST or None, request=request)
if registration_form.is_valid():
user = registration_form.save()
_backend_hackend(request, user)
return HttpResponseRedirect(request.REQUEST.get('next', '/'))
context = {
'registration_form': registration_form,
'months': range(1, 13),
'years': range(2011, 2036),
}
return TemplateResponse(request, 'accounts/register.html', context)
def registration(request):
if request.user.is_authenticated():
return HttpResponseRedirect(reverse("accounts-home"))
if request.method == "POST":
form = RegistrationForm(request, request.POST)
if form.is_valid():
user = form.save()
send_activation2(user)
return render_to_response('accounts/registration_done.html', locals(), context_instance=RequestContext(request))
else:
form = RegistrationForm(request)
return render_to_response('accounts/registration.html', locals(), context_instance=RequestContext(request))
def register_user(request):
args = {}
args.update(csrf(request))
if request.method == 'POST':
form = RegistrationForm(request.POST)
args['form'] = form
if form.is_valid():
form.save() # save user to database if form is valid
username = form.cleaned_data['username']
email = form.cleaned_data['email']
salt = hashlib.sha1(str(random.random())).hexdigest()[:5]
activation_key = hashlib.sha1(salt+email).hexdigest()
key_expires = datetime.datetime.today() + datetime.timedelta(2)
#Get user by username
user=User.objects.get(username=username)
# Create and save user profile
new_profile = UserProfile(user=user, activation_key=activation_key,
key_expires=key_expires)
new_profile.save()
# Send email with activation key
email_subject = 'Account confirmation'
email_body = "Hey %s, thanks for signing up. To activate your account, click this link within \
48hours http://127.0.0.1:8000/accounts/confirm/%s" % (username, activation_key)
send_mail(email_subject, email_body, '*****@*****.**',
[email], fail_silently=False)
return HttpResponseRedirect('/accounts/register_success')
else:
args['form'] = RegistrationForm()
return render_to_response('accounts/register.html', args, context_instance=RequestContext(request))
def registration(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = form.save()
password = new_user.password
new_user.set_password(password)
create_cloud_container ( new_user.username )
new_user.save()
user = authenticate(username=new_user.username, password=password)
login(request, user)
return HttpResponseRedirect('/%s' % user.username)
else:
form = RegistrationForm()
return render(request, 'registration.html', {'form': form}, context_instance=RequestContext(request))
def register(request):
"""
User registration view.
"""
navbarlinks = list_navbarlinks(request, ["Registration", "Help page"])
navbarlinks.append({"url": "/help#helpsection_registrationpage", "title": "Help page", "icon": "question-sign"})
shortcutlinks = list_shortcutlinks(request, ["Registration"])
auth_email = request.session["auth_email"]
auth_firstname = request.session["auth_firstname"]
auth_surname = request.session["auth_surname"]
auth_data = {"auth_email": auth_email, "auth_firstname": auth_firstname, "auth_lastname": auth_surname}
if request.method == 'POST':
data = request.POST.copy()
data.update(auth_data)
form = RegistrationForm(data=data)
if form.is_valid():
try:
user = form.save()
request.session["registration_state"] = "done"
user = authenticate(email=auth_email, password="******")
if user.is_active:
django_login(request, user)
request.session["user"] = user.annotator_id.annotator_id
except IntegrityError:
# catch "UNIQUE constraint failed" error
# May catch other errors in which case the error message displayed in the UI would not be accurate
return render_to_response(
'accounts/register.html',
{'navbarlinks': navbarlinks, 'shortcutlinks': shortcutlinks, 'form': form, 'alreadytaken': True},
context_instance=RequestContext(request)
)
return redirect('/interface_main')
else:
print form.errors
else:
form = RegistrationForm(data=auth_data)
return render_to_response('accounts/register.html', {
'navbarlinks': navbarlinks,
'shortcutlinks': shortcutlinks,
'auth_email': auth_email,
'auth_firstname': auth_firstname,
'auth_lastname': auth_surname,
'form': form,}, context_instance=RequestContext(request))
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
new_user = form.save()
# messages.info(request, "Thanks for registering. You are now logged in.")
new_user = authenticate(username= request.POST['email'],
password= request.POST['password1'])
login(request, new_user)
return HttpResponseRedirect('/dashboard/')
else:
form = RegistrationForm()
token = {}
token.update(csrf(request))
print token
token['form'] = form
return render_to_response('accounts/register.html', token)
def register(request):
if not request.user.is_authenticated():
title = 'register'
form = RegistrationForm(request.POST or None)
if request.POST and form.is_valid():
user = form.save()
if user:
return redirect('accounts:login')
context = {
'form': form,
'title':title,
}
return render(request, 'accounts/base.html', context)
else:
return redirect('accounts:view')
def register(request):
if request.method == 'POST':
form = RegistrationForm(request.POST)
print("Create registration form by POST")
if form.is_valid():
print("form is valid")
user = form.save()
# return HttpResponseRedirect('accounts/login')
return HttpResponseRedirect('/')
# if user is not None and user.is_active:
# auth.login(request, user)
# return HttpResponseRedirect('/')
else:
# form = EmailUserCreationForm()
form = RegistrationForm()
errors_msg = 'form create fail'
return render_to_response('registration/register.html', RequestContext(request, locals()))
def register(request, template_name=None):
"""Handle user registration.
"""
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
user = form.save()
profile = UserProfile.objects.create(user=user)
username = request.POST['username']
password = request.POST['password1']
user = authenticate(username=username, password=password)
login(request, user)
return HttpResponseRedirect(reverse('problems_index'))
else:
form = RegistrationForm()
return render_to_response(template_name,
{'form': form},
context_instance=RequestContext(request))
def register(request):
"""
User registration view.
"""
success = False
show_activation_info = False
if request.method == 'POST':
form = RegistrationForm(data=request.POST)
if form.is_valid():
user = form.save()
success = True
show_activation_info = not user.is_active
else:
form = RegistrationForm()
return render_to_response('register.html', {
'form': form, 'success': success, 'show_activation_info': show_activation_info
}, context_instance=RequestContext(request))
def register(request, template_name='accounts/register.html'):
"""
Allow a user to register an account.
:returns:
A :py:class:`!django.http.HttpResponse` on GET, which renders a
registration form.
A :py:class:`!django.http.HttpResponseRedirect on successful POST,
which redirects to the 'success' view.
"""
context = {}
post_signup_url = request.REQUEST.get('next') or 'register_success'
if "post_signup_url" in request.session:
post_signup_url = request.session["post_signup_url"]
reg_form = RegistrationForm(request.POST or None)
profile_form = UserProfileForm(request.POST or None)
if reg_form.is_valid() and profile_form.is_valid():
user = reg_form.save()
if user.user_profile is not None:
# Re-make the profile form against the auto-created user profile
profile_form = UserProfileForm(request.POST,
instance=user.user_profile)
user_profile = profile_form.save(commit=False)
user_profile.user = user
user_profile.activation_key = user_profile.generate_activation_key()
user_profile.detected_country = request.country
user_profile.preferred_currency = request.session.get('preferred_currency', '')
user_profile.save()
Events(request).user_signup(user)
# logging him in
user.backend = 'django.contrib.auth.backends.ModelBackend'
auth_login(request, user)
request.session['new_user'] = True
messages.success(request, REGISTER_SUCCESS_MESSAGE)
return redirect(post_signup_url)
context.update({'reg_form': reg_form, 'profile_form': profile_form})
return render(request, template_name, context)
def register(request, template_name="registration/register.html"):
if request.method == 'POST':
postdata = request.POST.copy()
form = RegistrationForm(postdata)
if form.is_valid():
user = form.save(commit=False)
user.email = postdata.get('email', '')
user.save()
un = postdata.get('username', '')
pw = postdata.get('password1', '')
from django.contrib.auth import login, authenticate
new_user = authenticate(username=un, password=pw)
if new_user and new_user.is_active:
login(request, new_user)
url = reverse('accounts:my_account')
return HttpResponseRedirect(url)
else:
form = RegistrationForm()
page_title = 'User Registration'
return render(request, template_name, locals())
def register(request, template_name="registration/register.html"):
""" view displaying customer registration form """
if request.method == 'POST':
postdata = request.POST.copy()
form = RegistrationForm(postdata)
if form.is_valid():
#form.save()
user = form.save(commit=False) # new
user.email = postdata.get('email','') # new
user.save() # new
un = postdata.get('username','')
pw = postdata.get('password1','')
from django.contrib.auth import login, authenticate
new_user = authenticate(username=un, password=pw)
if new_user and new_user.is_active:
login(request, new_user)
url = urlresolvers.reverse('my_account')
return HttpResponseRedirect(url)
else:
form = RegistrationForm()
page_title = 'User Registration'
return render_to_response(template_name, locals(), context_instance=RequestContext(request))
def login_or_registration(request, template_name='accounts/login_or_registration.html'):
registration_form = RegistrationForm()
login_form = AuthenticationForm()
if request.method == 'POST':
# clean the location field from the SRID=...; part which olwidget.js(?) inserts
post_data = dict(request.POST) # we need this because QueryDict is immutable
title = request.POST.get('title')
category = request.POST.get('category')
location_string = ''.join(post_data.get('location')) # use ''.join() to stringify the list
if location_string:
# Extract the SRID=...; part of the location value
post_data['location'] = location_string.replace(''.join(re.findall('(SRID=.*;)POINT', location_string)), '')
registration_form = RegistrationForm(request.POST)
# authenticate and log the user in after the account in created
if registration_form.is_valid():
new_user = registration_form.save(commit=False)
username = registration_form.cleaned_data['username']
password = registration_form.cleaned_data['password']
new_user.set_password(password)
new_user.save()
new_user = authenticate(username=username, password=password)
login(request, new_user)
return HttpResponseRedirect('/listings/post/?title=%s&category=%s' % (title, category))
title = request.GET.get('title')
category = request.GET.get('category')
context = {
"registration_form": registration_form,
"login_form": login_form,
"title": title,
"category": category,
}
return render_to_response(template_name, context, RequestContext(request))
