def test_sign_up_with_invalid_password(self):
"""
Ensure that the SignupForm enforces the correct restrictions on
passwords.
"""
# Test: passwords must meet the minimum password length
signup_form = SignupForm(
data={
"username": self.username,
"email": self.email,
"password": self.password[:6],
"repassword": self.password[:6],
}
)
self.assertFalse(signup_form.is_valid())
# Test: passwords must not be too common
signup_form = SignupForm(
data={
"username": self.username,
"email": self.email,
"password": "******",
"repassword": "******",
}
)
self.assertFalse(signup_form.is_valid())
def test_cannot_sign_up_existing_username_or_email(self):
"""
Users should be unable to sign up with a username or email that's
already been registered.
"""
signup_form = SignupForm(data=self.form_data)
self.assertTrue(signup_form.is_valid())
User.objects.create_user(
username=self.username, password=self.password, email=self.email
)
# Can't sign up same username twice
signup_form = SignupForm(
data={
"username": self.username,
"email": random_email(self.rd),
"password": self.password,
"repassword": self.password,
}
)
self.assertFalse(signup_form.is_valid())
# Can't sign up same email twice
signup_form = SignupForm(
data={
"username": random_username(self.rd),
"email": self.email,
"password": self.password,
"repassword": self.password,
}
)
self.assertFalse(signup_form.is_valid())
def register(request, template_name="registration/register.html"):
""" Lida com o cadastro de um usuario. """
cpf_error_message = []
new_costumer = []
if request.method == "POST":
cpf = request.POST["cpf"]
if cpf.isdigit() and not len(cpf) == 11:
cpf_error_message = "CPF deve ter 11 digitos."
# inicializa os formularios com as informacoes obtidas do request.POST.
signup_form = SignupForm(request.POST)
regis_form = UserCreationFormExtended(request.POST)
# caso esteja tudo ok, um novo usuario eh criado.
if not cpf_error_message and signup_form.is_valid() and regis_form.is_valid():
new_user = regis_form.save(request.POST)
new_costumer = registerPOSTHandler(request.POST, new_user)
else:
signup_form = SignupForm()
regis_form = UserCreationFormExtended()
return render_to_response(
template_name,
{
"object": new_costumer,
"signup_form": signup_form,
"regis_form": regis_form,
"cpf_error_form": cpf_error_message,
},
context_instance=RequestContext(request),
)
def post(self, request):
error_messages = []
form = SignupForm(request.POST)
if form.is_valid():
first_name = form.cleaned_data.get('first_name')
last_name = form.cleaned_data.get('last_name')
username = form.cleaned_data.get('usr')
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('pwd')
blog_name = form.cleaned_data.get('blog_name')
users = User.objects.filter(username=username)
if len(users) == 0:
new_user = User()
new_user.username = username
new_user.first_name = first_name
new_user.last_name = last_name
new_user.email = email
new_user.set_password(password)
new_user.save()
return redirect('home')
else:
error_messages.append(
'El username {0} ya existe. Pruebe con otro'.format(
username))
context = {'errors': error_messages, 'signup_form': form}
return render(request, 'users/signup.html', context)
def test_signup(self):
"""
Submit some valid data to the SignUp form, and ensure that the
form validates it.
"""
signup_form = SignupForm(data=self.form_data)
self.assertTrue(signup_form.is_valid())
def post(self, request):
"""
Procesa el login de un usuario
:param request: objeto HttpRequest
:return: objeto HttpResponse con el formulario renderizado
"""
form = SignupForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
# comprobamos si existe el usuario
if User.objects.filter(username=username).exists():
messages.error(request, 'Ya existe el usuario')
else:
email = form.cleaned_data.get('email')
first_name = form.cleaned_data.get('first_name')
last_name = form.cleaned_data.get('last_name')
user = User.objects.create_user(username=username,
first_name=first_name,
last_name=last_name,
email=email,
password=password)
messages.success(request, "Usuario Creado")
django_login(request, user)
return redirect('home')
username = form.cleaned_data.get('username')
if username:
messages.error(
request, "Compruebe los campos obligatorios y formato correo")
else:
messages.error(request,
"Usuario no puede dejarlo en blanco ni existir")
context = {'form': form}
return render(request, 'users/signup.html', context)
def post(self, request):
if request.user.is_authenticated:
return redirect('home')
form = SignupForm(request.POST)
if form.is_valid():
first_name = form.cleaned_data.get('fname')
last_name = form.cleaned_data.get('lname')
email = form.cleaned_data.get('email')
username = form.cleaned_data.get('usr')
password = form.cleaned_data.get('pwd')
User.objects.create_user(username=username,
email=email,
password=password,
first_name=first_name,
last_name=last_name)
user = authenticate(username=username, password=password)
if user is None:
messages.error(request, 'Usuario/contraseña incorrectos')
else:
django_login(request, user)
url = request.GET.get('next', 'home')
return redirect(url)
return self.render_template_with_form(request, form)
def post(self, request):
"""
Registra a un usario con la información de POST
"""
form = SignupForm(request.POST)
if form.is_valid():
success_message = ''
error_message = ''
possible_user = User.objects.filter(username=form.cleaned_data.get('usr'))
if len(possible_user) > 0:
error_message = u'El nombre de usuario ya está siendo usado. Por favor elija otro'
else:
new_user = User()
new_user.username = form.cleaned_data.get('usr')
new_user.first_name = form.cleaned_data.get('fst_name')
new_user.last_name = form.cleaned_data.get('lst_name')
new_user.email = form.cleaned_data.get('email')
new_user.password = make_password(form.cleaned_data.get('pwd'))
new_user.save()
form = SignupForm() # reiniciamos el formulario
success_message = u'Usuario ' + new_user.username + u' registrado con éxito! '
success_message += u'<a href="{0}">'.format(
reverse(u'users_login', args=[])
)
success_message += u'Entrar'
success_message += u'</a>'
context = {
'form': form,
'success_message': success_message,
'error_message': error_message
}
return render(request, 'users/signup.html', context)
def signup(request):
# this is a form submission
form = SignupForm(request.POST)
if not form.is_valid():
# this means we were sent a bad request - let the front end know
return HttpResponse("failure")
if User.objects.filter(username=form.cleaned_data['username']).exists():
return HttpResponse("user already exists sucka")
# check for other info
new_user = User(
username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
phone=form.cleaned_data['phone'],
password=make_password(form.cleaned_data['password'], 'saltysalt',
'bcrypt'),
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
access_token=uuid.uuid4(),
).save()
object = {'access_token': new_user.access_token}
return HttpResponse(json.dumps(object), content_type="application/json")
def signup(request):
# this is a form submission
form = SignupForm(request.POST)
if not form.is_valid():
# this means we were sent a bad request - let the front end know
return HttpResponse("failure")
if User.objects.filter(username=form.cleaned_data['username']).exists():
return HttpResponse("user already exists sucka")
# check for other info
new_user = User(
username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
phone=form.cleaned_data['phone'],
password=make_password(form.cleaned_data['password'], 'saltysalt', 'bcrypt'),
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
access_token=uuid.uuid4(),
).save()
object = {
'access_token': new_user.access_token
}
return HttpResponse(json.dumps(object), content_type="application/json")
def signup(request):
"""
Muestra un formulario para registrar a un nuevo usuario y lo crea si la petición es POST
:param request: HttpRequest
:return: HttpResponse
"""
success_message = []
if request.method == "GET":
form = SignupForm()
else:
form = SignupForm(request.POST)
if form.is_valid():
new_user = form.save() # Guarda el objeto User y lo devuelve
new_user = authenticate(username=request.POST["username"], password=request.POST["password1"])
django_login(request, new_user)
form = SignupForm()
success_message = "<h4>¡El usuario se ha creado con éxito! --> "
success_message += '<a href="{0}">'.format(reverse("posts_main"))
success_message += "Entrar"
success_message += "</a></h4>"
success_message += "<hr>"
else:
form = SignupForm()
context = {"form": form, "success_message": success_message}
return render(request, "users/signup.html", context)
def signup(request):
if request.method != "POST":
signup_form = SignupForm()
return render(request, "users/signup.html", locals())
signup_form = SignupForm(request.POST)
if signup_form.is_valid():
email = signup_form.cleaned_data['email']
username = signup_form.cleaned_data['username']
password = signup_form.cleaned_data['password']
if User.objects.filter(username__iexact=username).exists():
errors = signup_form._errors.setdefault("username", ErrorList())
errors.append(u"Already Exists")
return render(request, "account/signup.html", locals())
user = signup_form.save(commit=False)
user.set_password(password)
user.save()
user = authenticate(username=username, password=password)
django_login(request, user)
next = request.GET.get('next', '')
if next == '':
next = '/'
return HttpResponseRedirect(next)
return render(request, "users/signup.html", locals())
def post(self, request):
"""
Signs up a new user
:param request: HttpRequest object
:return: HttpResponse object
"""
form = SignupForm(request.POST)
context = dict()
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
email = form.cleaned_data.get('email')
first_name = form.cleaned_data.get('first_name')
last_name = form.cleaned_data.get('last_name')
new_user = User.objects.create_user(username=username,
password=password,
email=email,
first_name=first_name,
last_name=last_name)
if new_user:
# User created
return login_and_redirect(request, new_user)
else:
# Non created user
context['error'] = "Error creating user"
context['form'] = form
return render(request, 'signup.html', context)
def sign_up(request):
"""
The page visited by a user when they receive a signup token. The site checks
that the token is valid before the user is able to continue on to the
signup page.
"""
# Request must include a valid authentication token
token = request.GET.get("token", None)
valid_token = True
if token is None:
valid_token = False
else:
# Check that token is valid
matching_token = SignupToken.objects.filter(token=token)
if not matching_token.exists():
valid_token = False
else:
matching_token = matching_token[0]
if not valid_token:
return HttpResponseForbidden()
# Display signup form
form = SignupForm(request.POST if request.POST else None,
initial={"email": matching_token.email})
if request.POST and form.is_valid():
new_user = form.save()
matching_token.delete()
# Log the user in and redirect them to the dashboard
login(request, new_user)
return redirect("research dashboard")
return render(request, "sign_up.html", context={"form": form})
def post(self, request):
"""
Crea un user en base a la información POST
:param request: HttpRequest
:return: HttpResponse
"""
success_message = ''
form = SignupForm(request.POST)
if form.is_valid():
user = User()
user.username = form.cleaned_data.get('usr')
user.first_name = form.cleaned_data.get('first_name')
user.last_name = form.cleaned_data.get('last_name')
user.email = form.cleaned_data.get('email')
user.set_password(form.cleaned_data.get('password'))
user.save()
blog = Blog()
blog.title = "My first blog"
blog.owner = user
blog.save()
success_message = 'Creado con éxito!'
success_message += '<a href="{0}">'.format(
reverse('post_home', args=[])
)
success_message += 'go Home!'
success_message += '</a>'
context = {
'form': form,
'success_message': success_message
}
return render(request, 'users/new_user.html', context)
def post(self, request):
error_messages = []
form = SignupForm(request.POST)
if form.is_valid():
first_name = form.cleaned_data.get("first_name")
last_name = form.cleaned_data.get("last_name")
username = form.cleaned_data.get("usr")
email = form.cleaned_data.get("email")
password = form.cleaned_data.get("pwd")
blog_name = form.cleaned_data.get("blog_name")
users = User.objects.filter(username=username)
if len(users) == 0:
new_user = User()
new_user.username = username
new_user.first_name = first_name
new_user.last_name = last_name
new_user.email = email
new_user.set_password(password)
new_user.save()
blog = Blog()
blog.name = blog_name
blog.author = new_user
blog.save()
return redirect("posts_home")
else:
error_messages.append("El username {0} ya existe. Pruebe con otro".format(username))
context = {"errors": error_messages, "signup_form": form}
return render(request, "users/signup.html", context)
def signup(request):
if request.method != "POST":
signup_form = SignupForm()
return render(request, "users/signup.html", locals())
signup_form = SignupForm(request.POST)
if signup_form.is_valid():
email = signup_form.cleaned_data['email']
username = signup_form.cleaned_data['username']
password = signup_form.cleaned_data['password']
if User.objects.filter(username__iexact=username).exists():
errors = signup_form._errors.setdefault("username", ErrorList())
errors.append(u"Already Exists")
return render(request, "account/signup.html", locals())
user = signup_form.save(commit=False)
user.set_password(password)
user.save()
user = authenticate(username=username, password=password)
django_login(request, user)
next = request.GET.get('next', '')
if next == '':
next = '/'
return HttpResponseRedirect(next)
return render(request, "users/signup.html", locals())
def post(self, request):
form = SignupForm(request.POST)
if form.is_valid():
#Guardar el usuario nuevo
new_user = form.save()
blog = Blog()
blog.name = "Blog de {}".format(new_user.username)
blog.owner = new_user
blog.save()
#Poner los campos en blanco
form = SignupForm()
return redirect('posts_home')
else:
#Pregunta. En el html pq no me pinta los campos de nuevo
form = SignupForm()
context = {
'signup_form': form,
'message': 'Hay errores en el formulario. Intenta de nuevo.'
}
return render(request, 'users/signup.html', context)
def signup(request):
"""if request.method == 'POST':
username = request.POST['username']
password = request.POST['password']
password_confirmation = request.POST['password_confirmation']
if password != password_confirmation:
return render(request, 'users/signup.html', {'error' : 'Las contraseñas no coinciden'})
try:
usuario = User.objects.create_user(username=username, password=password)
except IntegrityError:
return render(request, 'users/signup.html', {'error' : 'El usuario ya existe'})
usuario.first_name = request.POST['first_name']
usuario.last_name = request.POST['last_name']
usuario.email = request.POST['email']
usuario.save()
profile = Profile(user=usuario)
profile.save()
return redirect('login')
return render(request, 'users/signup.html')"""
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return redirect('login')
else:
form = SignupForm()
return render(request=request,
template_name='users/registro.html',
context={'form': form})
def post(self, request):
error_messages = []
form = SignupForm(request.POST)
if form.is_valid():
first_name = form.cleaned_data.get('first_name')
last_name = form.cleaned_data.get('last_name')
username = form.cleaned_data.get('usr')
email = form.cleaned_data.get('email')
password = form.cleaned_data.get('pwd')
blog_name = form.cleaned_data.get('blog_name')
users = User.objects.filter(username=username)
if len(users) == 0:
new_user = User()
new_user.username = username
new_user.first_name = first_name
new_user.last_name = last_name
new_user.email = email
new_user.set_password(password)
new_user.save()
return redirect('home')
else:
error_messages.append('El username {0} ya existe. Pruebe con otro'.format(username))
context = {
'errors': error_messages,
'signup_form': form
}
return render(request, 'users/signup.html', context)
def user_signup(request):
if request.user.is_authenticated():
return HttpResponseRedirect('/')
else:
message = ''
if request.method == 'POST':
f = SignupForm(request.POST)
if f.is_valid():
user = f.save()
user = authenticate(email=f.cleaned_data['email'],
password=f.cleaned_data['password'])
#login(request, user)
user.send_verification_mail(request)
message = """Un email de confirmación fué enviado al correo proporcionado.
Muchas gracias.."""
else:
f = SignupForm()
return render(request, 'users/user_signup.html', {
'form': f,
'message': message
})
def post(self, request):
form = SignupForm(request.POST)
context = dict()
if form.is_valid():
username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
email = form.cleaned_data.get('email')
first_name = form.cleaned_data.get('first_name')
last_name = form.cleaned_data.get('last_name')
new_user = User.objects.create_user(username=username,
password=password,
email=email,
first_name=first_name,
last_name=last_name)
blog_created = Blog.objects.create(user=new_user,
title='El blog de ' +
new_user.username,
created_date=timezone.now())
if new_user and blog_created:
django_login(request, new_user)
return redirect('home')
else:
context['error'] = _("signup.post.error")
context['form'] = form
return render(request, 'signup.html', context)
def frontpage(request):
if request.user.is_authenticated:
return redirect('/' + request.user.username + '/')
else:
if request.method == 'POST':
if 'signupform' in request.POST:
signupform = SignupForm(data=request.POST)
signinform = SigninForm()
if signupform.is_valid():
username = signupform.cleaned_data['username']
password = signupform.cleaned_data['password1']
signupform.save()
user = authenticate(username=username, password=password)
login(request, user)
return redirect('/')
else:
signinform = SigninForm(data=request.POST)
signupform = SignupForm()
if signinform.is_valid():
login(request, signinform.get_user())
return redirect('/feed')
else:
signupform = SignupForm()
signinform = SigninForm()
return render(request, 'frontpage.html', {
'signupform': signupform,
'signinform': signinform
})
def post(self, request):
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return redirect("login_page")
else:
messages.error(request, "Vuelva a intentarlo")
return render(request, "signup_form.html", {'form': form})
def test_create_user(self):
"""Test user creation"""
form = SignupForm(data=self.get_data_for_signup_form())
response = self.client.post(reverse("signup"), form=form)
self.assertEqual(response.status_code, 200)
self.assertTrue(form.is_valid())
def post(self, request):
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return redirect('users:login')
return render(request=request,
template_name=self.template_name,
context={'form': form})
def post(self, request):
form = SignupForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data.get("username")
raw_password = form.cleaned_data.get("password1")
authenticated_user = authenticate(username=username,
password=raw_password)
django_login(request, authenticated_user)
return redirect('home_page')
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return redirect('login')
else:
form = SignupForm()
return render(request=request, template_name = 'users/signup.html', context = {'form' : form})
def signup_view(request):
if (request.method == 'POST'):
form = SignupForm(request.POST)
if (form.is_valid()):
form.save()
return redirect('users:login')
else:
form = SignupForm()
return render(request, 'users/signup.html', {'form': form})
def signup(request):
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return redirect("login")
else:
form = SignupForm()
return render(request=request,
template_name="users/signup.html",
context={"form": form})
def post(self, request):
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
django_login(request, user)
first_blog = Blog(owner=user,
title=user.first_name + ' first Blog')
first_blog.save()
return redirect('home')
context = {'form': form}
return render(request, 'users/login.html', context)
def test_create_user_without_username(self):
"""Test user creation with no username"""
data_for_form = self.get_data_for_signup_form()
data_for_form["username"] = None
form = SignupForm(data=data_for_form)
response = self.client.post(reverse("signup"), form=form)
self.assertEqual(response.status_code, 200)
self.assertFalse(form.is_valid())
self.assertFormError(response, "form", "username",
"This field is required.")
def signup(request):
signup_form = SignupForm(data=request.POST)
if request.method == 'POST':
if signup_form.is_valid():
username = signup_form.clean_username()
password = signup_form.clean_passwordconfirm()
signup_form.save()
user = authenticate(username=username, password=password)
login(request, user)
return redirect('/')
else:
return signup(request, signup_form=signup_form)
return redirect('/')
def signup(request):
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
user = User.objects.create_user(
form.cleaned_data["username"],
form.cleaned_data["email"],
form.cleaned_data["password"],
)
else:
form = SignupForm()
data = {"signup_form": form}
return render(request, "signup.html", data)
def post(self, request):
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return redirect('login_page')
error_messages = ['Signup not valid', ]
context = {
'errors': error_messages,
'signup_form': form
}
return render(request, 'signup_form.html', context)
def post(self, request):
register_form = SignupForm(request.POST)
if register_form.is_valid():
username = register_form.cleaned_data["username"]
email = register_form.cleaned_data["email"]
first_name = register_form.cleaned_data["first_name"]
last_name = register_form.cleaned_data["last_name"]
password = register_form.cleaned_data["password"]
new = User.objects.create(username=username, email=email, first_name=first_name, last_name=last_name,
password=password)
new.save()
login(request, new)
return HttpResponseRedirect(reverse("internal:overview"))
return render(request, "users/signup.html", {"form": register_form})
def test_password_and_repassword_must_match(self):
"""
In the signup form, the two passwords that the user enters
must match with one another.
"""
signup_form = SignupForm(
data={
"username": self.username,
"email": self.email,
"password": random_password(self.rd),
"repassword": random_password(self.rd),
}
)
self.assertFalse(signup_form.is_valid())
def post(self, request):
message = ""
signup_form = SignupForm(request.POST)
if signup_form.is_valid():
new_user = signup_form.save(commit=False)
password = signup_form.cleaned_data['password']
new_user.set_password(password)
new_user.save()
signup_form = SignupForm()
message = "usuario creado"
context = {'form': signup_form, 'message': message}
return render(request, 'users/signup.html', context)
def test_signup_form_valid_data(self):
"""Test signup form with valid data"""
user_password = faker.password()
form = SignupForm(
data={
"username": faker.first_name(),
"unconfirmed_email": faker.email(),
"birthday": faker.date_time(),
"first_name": faker.first_name(),
"last_name": faker.last_name(),
"password1": user_password,
"password2": user_password,
})
self.assertTrue(form.is_valid())
def signup(request):
signup_form = SignupForm(request.POST)
#goal = request.POST.get('goal')
goal = None
if signup_form.is_valid():
username = signup_form.cleaned_data['username']
email = signup_form.cleaned_data['email']
password = signup_form.cleaned_data['password']
user = User.objects.create_user(username, email, password)
user = authenticate(username=username, password=password)
login(request, user)
print user.api_key
return HttpResponseRedirect("/")
else:
return render_to_response("authorize.html", {'signup_form': signup_form, 'goal': goal}, context_instance=RequestContext(request))
def register(request):
if request.method == 'POST': # If the form has been submitted...
form = SignupForm(request.POST) # A form bound to the POST data
if form.is_valid():
username=form.cleaned_data['username']
email=form.cleaned_data['email']
password=form.cleaned_data['password']
user = User.objects.create_user(username, email,password)
user = django_auth.authenticate(username=username,
password=password)
django_auth.login(request, user)
return redirect('home')
# TODO: Redirect to the page this came from
else:
form = SignupForm()
return render(request,'auth.html',{'loginform':LoginForm,'signupform': form})
def post(self, request):
"""
Método para cuando el signup viene del método HTTP get
:param request: HttpRquest
:return: render que contruye un HttpResponse con el template indicado
"""
# Mensaje de éxito al crear nuevo usuario
success_message = ''
# Crearemos un Django Form para presentarlo en la plantilla
# Todos los valores del formulario se inicializan con los valores que vienen en el POST
form = SignupForm(request.POST)
# Si el formulario es válido, guardamos usuario
if form.is_valid():
new_user = User.objects.create_user(form.cleaned_data.get('username'), form.cleaned_data.get('email'), form.cleaned_data.get('password'))
new_user.first_name = form.cleaned_data.get('first_name')
new_user.last_name = form.cleaned_data.get('last_name')
new_user.is_staff = False
# Guardamos usuario
new_user.save()
# Creamos blog con el nuevo usuario
blog = Blog()
blog.owner = new_user
blog.save()
# Reseteamos formulario
form = SignupForm()
success_message = 'OK'
# Creamos contexto con mensaje éxito
context = {
'signup_form': form,
'success_message': success_message
}
# Mandamos respuesta con error a través de la plantilla
return render(request, 'users/registro.html', context)
def post(self, request):
error_messages = []
form = SignupForm(request.POST)
if form.is_valid():
username = form.cleaned_data.get('usr')
password = form.cleaned_data.get('pwd')
email = form.cleaned_data.get('email')
user = User.objects.filter(email=email)
if user.exists():
error_messages.append('Ya existe un usuario con este email')
else:
# creamos el usuario
new_user = form.save()
new_user.set_password(new_user.password)
new_user.save()
form = SignupForm()
if new_user.is_active:
# nos autenticamos
user = authenticate(username=new_user.username, password=new_user.password)
# creamos el blog del usuario
blog = Blog(owner=new_user)
blog.title = 'Blog de ' + new_user.username
blog.save()
# redireccionamos a la página de inicio
django_login(request, user)
url = request.GET.get('next', 'wordplease_home')
return redirect(url)
else:
error_messages.append('El usuario no está activo, contacte con el administrador del sitio.')
context = {
'errors': error_messages,
'signup_form': form
}
return render(request, 'users/signup.html', context)
def post(self, request):
form = SignupForm(request.POST)
if form.is_valid():
clean_pass = form.cleaned_data.get('password')
new_user = form.save(commit=False)
new_user.set_password(clean_pass)
new_user.save()
user = authenticate(username=new_user.username, password=clean_pass)
if user is not None:
django_login(request, user)
url = request.GET.get('next', 'posts_home')
return redirect(url)
error_messages = []
context = {
'errors': error_messages,
'login_form': form
}
return render(request, 'users/signup.html', context)
