def post(self, request):
form = UserCreationForm(request.POST)
if form.is_valid():
user_obj = form.save(commit=False)
password = form.cleaned_data['password']
user_obj.set_password(password)
user_obj.is_superuser = False
user_obj.is_staff = False
user_obj.save()
send_mail = send_email(subject = 'Welcome To Envento', mail_from='*****@*****.**', to_emails=[form.cleaned_data['email']], template='includes/welcome.html', data={'username': form.cleaned_data['username']})
data = {
'success' :True,
'message': 'Welcome to Envento, Login to access account!',
}
return JsonResponse(data)
else:
error_message = dict([(key, [error for error in value]) for key, value in form.errors.items()])
data = {
'success' :False,
"message":error_message
}
return JsonResponse(data)
def register_view(request):
if request.method == 'GET':
form = UserCreationForm()
return render(request, 'register.html', {'form':form})
elif request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = User(username=form.cleaned_data['username'])
user = User(
username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
is_active=False #user не активный до подтверждения email
)
user.set_password(form.cleaned_data['password'])
user.save()
Profile.objects.create(user=user)
#токен для активации, его сложнее угадать, чем pk user
token = Token.objects.create(user=user)
activation_url=HOST_NAME + reverse('accounts:user_activate') + \
'?token={}'.format(token)
#отправка письма на email пользователя
user.email_user('Registration on the site localhost',
'To activate, follow the link: {}'.format(activation_url))
return redirect('webapp:index')
else:
return render(request, 'register.html', {'form':form})
def test_valid_user_creation_form(self):
"""
the test is to test a form with a valid data
"""
user_creation_form = {'id':2, 'email':'*****@*****.**', 'password':'******', 'first_name':'first_name', 'last_name':'last_name'}
form = UserCreationForm(data=user_creation_form)
self.assertTrue(form.is_valid())
def save(self):
"""
Сохранение через django формы
"""
# Добавление исполнителя как и во вьюхе authorization.views.registration_account
for performer in self.performers:
if performer['master']:
performer['name'] = performer['contactperson']
form = UserCreationForm(performer)
form_profile = BaseProfileForm(performer)
form_profile_phone = ProfilePhoneForm(performer)
if all([
form.is_valid(),
form_profile.is_valid(),
form_profile_phone.is_valid()
]):
user = form.save(commit=False)
profile = form_profile.save(commit=False)
profile.role = profile.ROLE_MASTER if performer[
'master'] else profile.ROLE_COMPANY
profile.save()
ProfileHash(profile=profile).save()
profile_phone = form_profile_phone.save(commit=False)
profile_phone.profile = profile
profile_phone.save()
if profile.role == profile.ROLE_COMPANY:
ProfileDirector(profile=profile).save()
ProfileBankDetails(profile=profile).save()
ProfileContactPerson(
profile=profile,
contact_person=performer['contactperson']).save()
user.profile = profile
user.is_active = False
user.save()
def register_view(request):
if request.method == 'GET':
form = UserCreationForm()
return render(request, 'register.html', {'form': form})
elif request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = User(
username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
is_active=False # user не активный до подтверждения email
)
user.set_password(form.cleaned_data['password'])
user.save()
# токен для активации, его сложнее угадать, чем pk user-а.
token = Token.objects.create(user=user)
activation_url = HOST_NAME + reverse('accounts:user_activate') + \
'?token={}'.format(token)
# отправка письма на email пользователя
user.email_user(
'Регистрация на сайте localhost',
'Для активации перейдите по ссылке: {}'.format(activation_url))
print(activation_url)
return redirect("webapp:todo_index")
else:
return render(request, 'register.html', {'form': form})
def test_user_without(self):
"""
Without data
"""
form_data = {}
form = UserCreationForm(data=form_data)
self.assertEqual(form.is_valid(), False)
def post(self, request, *args, **kwargs):
user_form = UserCreationForm(request.POST, prefix="user")
company_form = CompanyCreationForm(request.POST, request.FILES, prefix="company")
location_form = LocationCreationForm(request.POST, prefix="location")
forms_valid = False
if user_form.is_valid():
user = user_form.save(commit=False)
if user.user_type == USER_TYPE_COMPANY:
location_form.is_valid()
company_form.is_valid()
if company_form.is_valid() and location_form.is_valid():
company = company_form.save(commit=False)
user.save()
company.user = user
company.save()
location = location_form.save(commit=False)
location.company = company
location.save()
forms_valid = True
else:
forms_valid = True
user.save()
if forms_valid:
user = authenticate(username=user_form.cleaned_data['email'],
password=user_form.cleaned_data['password1'])
login(self.request, user)
return redirect('cowork:dashboard')
context = self.get_context_data(**kwargs)
context.update({'user_form': user_form,
'company_form': company_form,
'location_form': location_form})
return self.render_to_response(context)
def test_user_email(self):
"""
Wrong email
"""
form_data = {'user_type':0, 'email':'toemail', 'password': '******'}
form = UserCreationForm(data=form_data)
self.assertEqual(form.is_valid(), False)
def register(request, success_url='registration_complete',
template_name='accounts/registration_form.html',
extra_context=None):
"""
Allow a new user to register an account.
"""
if request.method == 'POST':
form = UserCreationForm(data=request.POST, files=request.FILES)
if form.is_valid():
cleaned_data = form.cleaned_data
new_user = User.objects.create_inactive_user(cleaned_data['email'], cleaned_data['password1'])
signals.user_registered.send(sender=User,
user=new_user,
request=request)
return redirect(success_url)
else:
form = UserCreationForm()
if extra_context is None:
extra_context = {}
context = RequestContext(request)
for key, value in extra_context.items():
context[key] = callable(value) and value() or value
return render_to_response(template_name,
{'form': form},
context_instance=context)
def register(request, *args, **kwargs):
form = UserCreationForm(request.POST or None)
if form.is_valid():
form.save()
print("User created")
return HttpResponseRedirect("/login/")
return render(request, "accounts/register.html", {"form": form})
def test_invalid_user_registration_form(self):
form = UserCreationForm({
'email': '*****@*****.**',
'name': 'Test User',
'password1': 'hoonoruru',
})
self.assertFalse(form.is_valid())
def setUp(self):
self.form_kwargs = {'username': '******', 'email': '*****@*****.**'}
self.form = UserCreationForm(self.form_kwargs)
self.user = self.form.save(commit=False)
# We don't need to target the real URL here, just making an HttpRequest()
self.request = RequestFactory().get('/')
self.request.user = mommy.make(User, is_superuser=True)
self.site = 'SITE'
def test_email_on_user_add_w_password(self):
"""Send an email to the user on creation of their account when pw set"""
self.form_kwargs.update({'password1': 'a', 'password2': 'a'})
form = UserCreationForm(self.form_kwargs)
self.assertTrue(form.is_valid())
ProfileUserAdmin(User, self.site).save_model(
self.request, self.user, form, False,)
self.assertEqual(len(mail.outbox), 1)
def test_arise_password_dont_match(self):
form = UserCreationForm({
'email': '*****@*****.**',
'name': 'Test User',
'password1': 'hoonoruru',
'password2': 'hoonodruru',
})
self.assertFalse(form.is_valid())
def test_invalid_user_creation_form_email(self):
"""
the method test the invalid form data here testing the unique email address , we give our user an existing email address
and the email address must be unique
"""
user_creation_form = {'id':2, 'email':self.user.email, 'password':'******', 'first_name':'first_name', 'last_name':'last_name'}
form = UserCreationForm(data=user_creation_form)
self.assertFalse(form.is_valid())
self.assertIn('User with this Email already exists.', form.errors['email'])
def register_view(request):
form = UserCreationForm(request.POST or None)
if form.is_valid():
user = form.save(commit=False)
password = form.cleaned_data.get("password")
user.save()
authenticate(username=user.username, password=password)
login(request, user=user)
redirect('/')
return render(request, 'user/register.html', locals())
def test_clean_username(self) -> None:
# A user with proto_user params does not exist yet.
proto_user = UserFactory.build()
form = UserCreationForm({
"username": proto_user.username,
"password1": proto_user._password,
"password2": proto_user._password,
})
assert form.is_valid()
assert form.clean_username() == proto_user.username
# Creating a user.
form.save()
# The user with proto_user params already exists,
# hence cannot be created.
form = UserCreationForm({
"username": proto_user.username,
"password1": proto_user._password,
"password2": proto_user._password,
})
assert not form.is_valid()
assert len(form.errors) == 1
assert "username" in form.errors
def test_user_creation_missing_data(self):
"""This test checks if the form can detect incomplete data"""
form = UserCreationForm(
data={
"first_name": "test",
"last_name": "user",
"password1": "test123",
"password2": "test123",
}
)
self.assertFalse(form.is_valid())
def test_invalid_user_creation_form_password(self):
"""
the method test the invalid form data here testing the password the password must be numbers and alphapet and not less than 8 charchter
"""
user_creation_form = {'id':2, 'email':'*****@*****.**', 'password':'******', 'first_name':'first_name', 'last_name':'last_name'}
form = UserCreationForm(data=user_creation_form)
self.assertFalse(form.is_valid())
self.assertIn('This password is too short. It must contain at least 8 characters.', form.errors['password'])
self.assertIn('This password is too common.', form.errors['password'])
self.assertIn('This password is entirely numeric.', form.errors['password'])
def test_form(self):
form_input = {
'username': '******',
'email': '*****@*****.**',
'password1': 'mypassword123',
'password2': 'mypassword123',
}
form = UserCreationForm(data=form_input)
self.assertTrue(form.is_valid())
def post(self, request, *args, **kwargs):
"""Handles the form validation and user registration
"""
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
email = form.cleaned_data.get("email")
raw_password = form.cleaned_data.get("password1")
user = authenticate(email=email, password=raw_password)
login(request, user)
return redirect("index")
return render(request, "auth_form.html", self.ctx)
def test_user_creation_valid_data(self):
"""This test checks if the form can be validated"""
form = UserCreationForm(
data={
"first_name": "test",
"last_name": "user",
"email": "*****@*****.**",
"password1": "test123",
"password2": "test123",
}
)
self.assertTrue(form.is_valid())
def test_user_creation_invalid_passwords(self):
"""This test checks if the form can detect non-matching passwords"""
form = UserCreationForm(
data={
"first_name": "test",
"last_name": "user",
"email": "*****@*****.**",
"password1": "test123",
"password2": "testabc",
}
)
self.assertFalse(form.is_valid())
def test_user_create_form_valid():
form = UserCreationForm(
data={
'email': '*****@*****.**',
'email1': '*****@*****.**',
'first_name': 'test',
'last_name': 'user',
'date_of_birth': '08/27/1975',
'password1': '@Password',
'password2': "@Password",
})
assert form.is_valid()
def register(request):
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
new_user = form.save()
return HttpResponseRedirect("/loggedin")
else:
form = UserCreationForm()
return render_to_response("registration/register.html", {
'form': form,},
context_instance=RequestContext(request)
)
def test_creation_form_valid(self):
'''
User can create unique and valid form
:return:
'''
data = {
'username': '******',
'email': '*****@*****.**',
'phone_number': '01049392222',
'password1': '!adkdkd33',
'password2': '!adkdkd33'}
form = UserCreationForm(data=data)
self.assertTrue(form.is_valid())
def register_user(request):
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/accounts/register_success/')
args = {}
args.update(csrf(request)) # csrf token
args['form'] = UserCreationForm() # blank UserCreationForm
return render_to_response('accounts/register.html', args)
def post(self, request, *args, **kwargs):
user_form = UserCreationForm(request.POST, prefix="user")
if user_form.is_valid():
user = user_form.save(commit=False)
user.user_type = 0
user.save()
user = authenticate(username=user_form.cleaned_data['email'],
password=user_form.cleaned_data['password1'])
login(self.request, user)
return redirect('index')
context = self.get_context_data(**kwargs)
context.update({'user_form': user_form})
return self.render_to_response(context)
def register(request, template_name="registration/register.html"):
if request.method == 'POST':
postdata = request.POST.copy()
form = UserCreationForm(postdata)
# user = MyUser()
# user.username = postdata.get('username')
# user.first_name = postdata.get('first_name')
# user.last_name = postdata.get('last_name')
# user.date_of_birth = postdata.get('date_of_birth')
# user.address = postdata.get('address')
# user.telephone = postdata.get('telephone')
# user.is_active = True
# user.save()
print(form.is_valid())
if form.is_valid():
form.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 = urlresolvers.reverse('login')
return HttpResponseRedirect(url)
else:
form = UserCreationForm()
page_title = 'User Registration'
return render_to_response(template_name,
locals(),
context_instance=RequestContext(request))
def test_user_creation_form_invalid():
form = UserCreationForm(
data={
'email': '*****@*****.**',
'email1': '*****@*****.**',
'first_name': 'test',
'last_name': 'user',
'date_of_birth': '08/27/1975',
'password1': '@Password',
'password2': '@Password'
})
assert form.is_valid() is False
assert 'email1' in form.errors
def validate_performers(self):
"""
Проверка валидности данных через django формы
"""
for performer in self.performers:
form = UserCreationForm(performer)
form_profile = BaseProfileForm(performer)
form_profile_phone = ProfilePhoneForm(performer)
if not form.is_valid():
raise FormValidationError(form, performer)
if not form_profile.is_valid():
raise FormValidationError(form, performer)
if not form_profile_phone.is_valid():
raise FormValidationError(form, performer)
def create_account(request):
form = UserCreationForm(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("account:profile")
return render(request, "accounts/create.html", {
"form": form,
})
def test_creation_form_invalid(self):
'''
User Can't Create duplicate User
:return:
'''
obj = MyUser.objects.get(email='*****@*****.**')
data = {
'username': obj.username,
'email': obj.email,
'phone_number': obj.phone_number,
'password1': obj.password,
'password2': obj.password}
form = UserCreationForm(data=data)
self.assertFalse(form.is_valid())
def register_view(request):
if request.method == 'GET':
form = UserCreationForm()
return render(request, 'register.html', {'form': form})
elif request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = User(username=form.cleaned_data['username'],
email=form.cleaned_data['email'])
user.set_password(form.cleaned_data['password'])
user.save()
login(request, user)
return redirect("webapp:index")
else:
return render(request, 'register.html', {'form': form})
def test_valid_user_registration_form_sends_email(self):
form = UserCreationForm({
'email': '*****@*****.**',
'name': 'Test User',
'password1': 'hoonoruru',
'password2': 'hoonoruru',
})
self.assertTrue(form.is_valid())
with self.assertLogs('accounts', level='INFO') as cm:
form.send_email()
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(len(cm.output), 1)
class ProfileAdminTests(TestCase):
def setUp(self):
self.form_kwargs = {'username': '******', 'email': '*****@*****.**'}
self.form = UserCreationForm(self.form_kwargs)
self.user = self.form.save(commit=False)
# We don't need to target the real URL here, just making an HttpRequest()
self.request = RequestFactory().get('/')
self.request.user = mommy.make(User, is_superuser=True)
self.site = 'SITE'
def test_email_on_user_add(self):
"""Send an email to the user on creation of their account when no pw set"""
ProfileUserAdmin(User, self.site).save_model(self.request, self.user, self.form, False,)
self.assertEqual(len(mail.outbox), 1)
def test_email_on_user_add_w_password(self):
"""Send an email to the user on creation of their account when pw set"""
self.form_kwargs.update({'password1': 'a', 'password2': 'a'})
form = UserCreationForm(self.form_kwargs)
self.assertTrue(form.is_valid())
ProfileUserAdmin(User, self.site).save_model(
self.request, self.user, form, False,)
self.assertEqual(len(mail.outbox), 1)
def test_no_email_on_user_edit(self):
"""No emails generated when `change` is True, we're editing an existing User"""
ProfileUserAdmin(User, self.site).save_model(self.request, self.user, self.form, True,)
self.assertEqual(len(mail.outbox), 0)
def register_view(request):
if request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = User(username=form.cleaned_data['username'],
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
email=form.cleaned_data['email'])
user.set_password(form.cleaned_data['password'])
user.save()
UserProfile.objects.create(user=user)
login(request, user)
return redirect('webapp:index')
else:
form = UserCreationForm()
return render(request, 'user_create.html', context={'form': form})
def book_detail(request, book_id):
book = get_object_or_404(Book, id=book_id)
likes = 0
top_rated_review = book.review_set.first()
for review in book.review_set.all():
if review.comment_set.count() > likes:
likes = review.comment_set.count()
top_rated_review = review
other_images = []
for bookImage in book.bookimage_set.all():
if bookImage.is_main == False:
other_images.append(bookImage)
context = {
'userLoginForm': UserLoginForm(),
'userCreationForm': UserCreationForm(),
'book': book,
'other_images': other_images,
'top_rated_review': top_rated_review,
'reviewForm': ReviewForm(),
'commentForm': CommentForm(),
}
return render(request, 'frontend/book_detail.html', context)
def post(self, request, *args, **kwargs):
form = UserCreationForm(request.POST)
if form.is_valid():
user = form.save()
# Generate an activation code
# and email it to the user.
account_activation(user)
messages.info(request, _(
'Your new account has been created. '
'You should receive an email soon with '
'instructions on how to activate your account.'
))
return redirect('accounts:login')
else:
return self.render_to_response({ 'form': form })
def new(request):
context = {}
user_form = UserCreationForm()
user_profile_form = UserProfileForm()
if request.method == "POST":
user_profile_form = UserProfileForm(data=request.POST)
if not user_profile_form.is_valid():
context['new_user_form'] = user_form
context['new_user_profile_form'] = user_profile_form
return render_to_response("new.html", RequestContext(request, context))
user_form = UserCreationForm(data=request.POST)
if user_form.is_valid():
user = User.objects.create_user(user_form.cleaned_data['username'],
user_form.cleaned_data['email'],
user_form.cleaned_data['password'])
if user_profile_form.is_valid():
user_profile = user_profile_form.save(commit=False)
user_profile.user = user
user_profile.save()
try:
team = Team.objects.get(name=request.POST['team'])
except:
team = Team(name=request.POST['team'])
team.save()
team_user = TeamUser(team=team, user=user)
team_user.save()
if request.POST.get("isadmin", False):
user.groups.add(Group.objects.get(name="Administrator"))
else:
user.groups.add(Group.objects.get(name="Standard User"))
return HttpResponseRedirect(reverse('accounts.views.login'))
else:
raise Exception("Form not valid")
else:
print user_form.errors
pass
context['new_user_form'] = user_form
context['new_user_profile_form'] = user_profile_form
return render_to_response("new.html", RequestContext(request, context))
def register(request):
args = {}
args.update(csrf(request))
args['form'] = UserCreationForm()
if request.POST:
newuser_from = UserCreationForm(request.POST)
if newuser_from.is_valid():
newuser_from.save()
newuser = auth.authenticate(username=newuser_from.cleaned_data['email'],
password=newuser_from.cleaned_data['password2'])
auth.login(request, newuser)
user = User.objects.get(id=auth.get_user(request).id)
f = open(create_image(user.username, user.username), 'rb')
username_image = File(f)
user.username_image.save(user.username + '.png', username_image)
user.save()
return redirect('/')
else:
args['form'] = newuser_from
return render(request, 'register1.html', args)
def create(request):
"""
Custom View to allow for custom users with username as email. Mitigates:
https://github.com/torchbox/wagtail/issues/158
"""
if request.POST:
form = UserCreationForm(request.POST)
if form.is_valid():
user = form.save()
messages.success(request, _("User '{0}' created.").format(user), buttons=[
messages.button(reverse('wagtailusers_users_edit', args=(user.id,)), _('Edit'))
])
return redirect('wagtailusers_users_index')
else:
messages.error(request, _("The user could not be created due to errors."))
else:
form = UserCreationForm()
return render(request, 'wagtailusers/users/create.html', {
'form': form,
})
def register(request, template="registration/register.html"):
if request.method == "POST":
user_creation_form = UserCreationForm(request.POST)
if user_creation_form.is_valid():
username = user_creation_form.cleaned_data["username"]
password = user_creation_form.cleaned_data["password1"]
default_view = user_creation_form.cleaned_data["default_view"]
user = user_creation_form.save()
user = authenticate(username=username, password=password)
# TODO:
# i had to assign user twice here. must authenticate before login,
# but form doesn't do that. should really return an authenticated user
# after user creation
login(request, user)
for UserModel in [Applicant, Broker, Agency, Landlord]:
UserModel.objects.get_or_create(user=user)
UserProfile.objects.get_or_create(user=user, default_view=default_view)
messages.info(request, "You have successfully created an account")
return HttpResponseRedirect(reverse("dashboard"))
else:
return direct_to_template(request, template, locals())
user_creation_form = UserCreationForm()
return direct_to_template(request, template, locals())
def test_form_user(self):
form_data = {"email": "*****@*****.**", "password1": "zosia12", "password2": "zosia12"}
form = UserCreationForm(data=form_data)
self.assertEqual(form.is_valid(), True)