def create(self, request, *args, **kwargs):
form = UserRegistrationForm(data=json.loads(request.body))
if form.is_valid(): # Check form data
form.save()
return Response(status=HTTP_201_CREATED)
else:
return Response(data=form.errors, status=HTTP_400_BAD_REQUEST)
def register(request):
if request.user.is_authenticated():
return redirect("users.views.profile")
if request.POST:
creation_form = UserCreationForm(request.POST)
profile_form = UserRegistrationForm(request.POST)
if creation_form.is_valid() and profile_form.is_valid():
assert creation_form.cleaned_data.get("password1") == creation_form.cleaned_data.get("password2")
new_user = creation_form.save(commit = False)
new_profile = profile_form.save(commit = False)
new_user.save()
new_profile.user = new_user
new_profile.save()
return login(request)
else:
creation_form = UserCreationForm()
profile_form = UserRegistrationForm()
return render(request, "register.html", {
"creation_form": creation_form,
"profile_form": profile_form
})
def test_UserRegistrationForm_invalid_email(self,
UserRegistrationForm_data):
UserRegistrationForm_data['email'] = 'inavlid_email'
form = UserRegistrationForm(data=UserRegistrationForm_data)
assert not form.is_valid()
with pytest.raises(ValueError):
form.save()
def test_UserRegistrationForm_invalid_password_does_not_match(
self, UserRegistrationForm_data):
UserRegistrationForm_data['password1'] = 'first-password'
UserRegistrationForm_data['password2'] = 'second-password'
form = UserRegistrationForm(data=UserRegistrationForm_data)
assert not form.is_valid()
with pytest.raises(ValueError):
form.save()
def test_invalid_password_confirm_field(self):
form_data = {
'username': USERNAME,
'email': EMAIL,
'password': PASSWORD,
'password_confirm': 'qwerty'
}
form = UserRegistrationForm(data=form_data)
self.assertFalse(form.is_valid())
def test_user_registration_form_valid_data(self):
form = UserRegistrationForm(data={
'username': '******',
'email': '*****@*****.**',
'password1': 'gamekhelbo',
'password2': 'gamekhelbo'
})
self.assertTrue(form.is_valid())
def post(self, request):
form = UserRegistrationForm(request.POST)
if form.is_valid():
print('Valid data')
# if username is not exsist
form.save()
return redirect('menu:home')
return self.get(request)
def test_form_is_valid(self):
form_data = {
'username': USERNAME,
'email': EMAIL,
'password': PASSWORD,
'password_confirm': PASSWORD
}
form = UserRegistrationForm(data=form_data)
self.assertTrue(form.is_valid())
def test_UserRegistrationForm_invalid_password(self,
UserRegistrationForm_data):
UserRegistrationForm_data['password1'] = 'password'
UserRegistrationForm_data['password2'] = 'password'
form = UserRegistrationForm(data=UserRegistrationForm_data)
assert not form.is_valid()
with pytest.raises(ValueError):
form.save()
def test_user_registration_form_valid_data(self):
form = UserRegistrationForm(data={
'username': '******',
'email': '*****@*****.**',
'password1': 'TestPass1!',
'password2': 'TestPass1!'
})
self.assertTrue(form.is_valid())
print('user registration form valid data pass')
def test_user_already_exists(self):
data = {
'email': '*****@*****.**',
'password1': 'test123',
'password2': 'test123',
}
form = UserRegistrationForm(data)
self.assertFalse(form.is_valid())
self.assertEqual(form['email'].errors,
['Пользователь с таким емайл уже зарегестрирован.'])
def post(self, request):
#post请求将执行这个函数
user_form = UserRegistrationForm(request.POST)
if user_form.is_valid():
cd = user_form.cleaned_data
new_user = user_form.save(commit=False)
new_user.set_password(cd["password"])
new_user.save()
return render(request, 'users/register_done.html',
{"new_user": new_user})
return HttpResponse("注册失败")
"""
def test_user_registration_form_clean_methods(self):
"""
Test form clean methods.
"""
form = UserRegistrationForm(data=self.data)
# instantiate form.is_valid() in order to run clean methods.
form.is_valid()
assert 'testpassword0004' in form.clean_password(), 'Returns password.'
assert 'testpassword0004' in form.cleaned_data.get(
'password'), 'Returns password if found in cleaned_data'
def test_user_registration_password_field_match_validation(self):
form = UserRegistrationForm(
data={
'first_name': self.user.first_name,
'last_name': self.user.last_name,
'email': '*****@*****.**',
'password': '******',
'confirm_password': '******',
'acct_type': 'IND',
'toc': True,
})
assert form.non_field_errors() == [
"Passwords don't match. Please check and try again."
], 'Returns validation error for matching pass/cofirm_pass'
def register_view(request):
form = UserRegistrationForm(request.POST or None)
if form.is_valid():
user = form.save()
profile = Profile.objects.create(user=user)
Character.objects.create(profile=profile,
first_name=FirstName.objects.create(
form=user.username.replace('_', ' ')))
messages.info(request,
f'Utworzono konto dla {user.username}! Zaloguj się!')
return redirect('users:login')
context = {'page_title': 'Utwórz profil', 'form': form}
return render(request, 'users/register.html', context)
def test_user_save(self):
data = {
'email': '*****@*****.**',
'password1': 'sbAB35EHR-*/',
'password2': 'sbAB35EHR-*/',
'first_name': 'Иван',
'last_name': 'Иванов',
}
form = UserRegistrationForm(data)
self.assertTrue(form.is_valid())
self.assertEqual(form.instance.email, '*****@*****.**')
form.save()
self.assertEqual(
User.objects.get(id=form.instance.id).email, '*****@*****.**')
def test_register_user_form(correo_1, correo_2, password_1, password_2,
is_valid):
comuna = baker.make("geo.Comuna")
data = {
"nombre": "Testman",
"apellido": "Sanchez",
"correo_1": correo_1,
"correo_2": correo_2,
"password_1": password_1,
"password_2": password_2,
"rut": "19136636",
"numero_serie_carnet": "123456789",
"comuna": comuna,
}
form = UserRegistrationForm(data=data)
assert form.is_valid() == is_valid
def test_user_registration_form_is_valid(self):
"""
Test .is_valid() of form.
"""
# Test will fail without hard coded kwargs
form = UserRegistrationForm(
data={
'first_name': self.user.first_name,
'last_name': self.user.last_name,
'email': '*****@*****.**',
'password': '******',
'confirm_password': '******',
'acct_type': 'IND',
'toc': True,
})
assert form.is_valid() == True, 'Returns True if form is valid.'
def test_user_registration_password_field_validation_error(self):
"""
Test form password length validation.
"""
form = UserRegistrationForm(
data={
'first_name': self.user.first_name,
'last_name': self.user.last_name,
'email': '*****@*****.**',
'password': '******',
'confirm_password': '******',
'acct_type': 'IND',
'toc': True,
})
assert form.has_error(
'password', code='password_short'
) == True, 'Returns True if length validation error.'
def registration(request):
if request.user.is_authenticated:
return redirect('index')
if request.method == 'POST':
# map the submitted form to the UserRegistrationForm
form = UserRegistrationForm(request.POST)
if form.is_valid():
form.save()
# log in the user immediately with given name
username = form.cleaned_data.get('username')
raw_password = form.cleaned_data.get('password1')
user = authenticate(username=username, password=raw_password)
login(request, user)
return redirect('index')
else:
return render(request=request,
template_name="users/registration.html",
context={"form": form})
# GET Request
form = UserRegistrationForm()
return render(request=request,
template_name="users/registration.html",
context={"form": form})
def register_customer(request):
if request.method == "POST":
user_form = UserRegistrationForm(request.POST)
customer_form = CustomerProfileForm(request.POST, request.FILES)
if user_form.is_valid() and customer_form.is_valid():
user_form.save()
username = user_form.cleaned_data["username"]
pwd = user_form.cleaned_data["password1"]
auth_user = authenticate(username=username, password=pwd)
login(request, auth_user)
customer = customer_form.instance
customer.user = auth_user
customer.email = auth_user.email
customer.save()
messages.success(request, f'Welcome to Bistro! Happy Fooding!')
return redirect('customer_dashboard')
else:
user_form = UserRegistrationForm()
customer_form = CustomerProfileForm()
context = {'uform': user_form, 'cform': customer_form}
return render(request, 'users/register_customer.htm', context)
def register_staff(request):
if request.method == "POST":
user_form = UserRegistrationForm(request.POST)
staff_form = StaffProfileForm(request.POST, request.FILES)
if user_form.is_valid() and staff_form.is_valid():
user_form.save()
user = user_form.instance
user.is_superuser = True
user.is_staff = True
user.save()
#auth_user = authenticate(username=username, password=pwd)
#login(request, auth_user)
staff = staff_form.instance
staff.user = user
staff.email = user.email
staff.save()
return redirect('staff_dashboard')
else:
user_form = UserRegistrationForm()
staff_form = StaffProfileForm()
context = {'uform': user_form, 'cform': staff_form}
return render(request, 'users/register_staff.htm', context)
def test_user_registration_form_is_bound(self):
"""
Test if form is bound by passed data.
"""
self.form = UserRegistrationForm(data={})
# As per Django documentation, the data={} will return True even if no
# kwargs passed.
assert self.form.is_bound == True, 'Returns True if form is bound by data.'
def test_user_registration_form_errors(self, client):
"""
Test form errors.
"""
self.form = UserRegistrationForm(data={})
assert 'This field is required.' in self.form[
'first_name'].errors, 'Reports error on form field.'
assert 'This field is required.' in self.form[
'email'].errors, 'Reports error on form field.'
def UserRegisterView(request):
if request.method == 'POST':
form = UserRegistrationForm(request.POST)
if form.is_valid():
form.save()
return redirect('landing-page')
else:
form = UserRegistrationForm()
return render(request, 'users/register.html', {'form': form})
def register_view(request):
if request.user.is_authenticated:
return redirect("home")
else:
title = "Create an Account"
form = UserRegistrationForm(request.POST or None, request.FILES
or None)
if form.is_valid():
user = form.save(commit=False)
password = form.cleaned_data.get("password1")
user.set_password(password)
user.save()
new_user = authenticate(email=user.email, password=password)
login(request, new_user)
return HttpResponseRedirect(reverse('home_page'))
context = {"title": title, "form": form}
return render(request, "users/form.html", context)
def post(self, request, *args, **kwargs):
user_form = UserRegistrationForm(request.POST)
profile_form = ProfileForm(request.POST)
if DjangoUser.objects.filter(username=request.POST['username']).exists():
messages.error(request, 'The user with this username already exists')
elif user_form.is_valid() and profile_form.is_valid():
new_user = user_form.save(commit=False)
new_user.set_password(user_form.cleaned_data['password'])
profile = Profile(user=new_user,
date_of_birth=profile_form.cleaned_data['date_of_birth'])
if request.FILES:
profile.photo = request.FILES['photo']
new_user.save()
profile.save()
login(request, new_user)
return redirect('blogs:posts')
else:
messages.error(request, 'Data is not valid.')
self.context['user_form'] = user_form
self.context['profile_form'] = profile_form
return render(request, 'users/register.html', self.context)
def global_context(request):
context = {}
context['main_arguments'] = ActionCategory.objects.all()
context['main_locations'] = Geoname.objects.all()
context['LESS_DEBUG'] = settings.LESS_DEBUG
context['LOGIN_URL'] = settings.LOGIN_URL
context['LOGOUT_URL'] = settings.LOGOUT_URL
if not request.user.is_authenticated():
context['registration_form'] = UserRegistrationForm()
return context
def register(request):
if request.method=='POST':
form = UserRegistrationForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
user.save()
current_site = get_current_site(request)
mail_subject = 'Activate your blog account.'
message = render_to_string('acc_active_email.html', {
'user': user,
'domain': current_site.domain,
'uid':urlsafe_base64_encode(force_bytes(user.pk)).decode(),
'token':account_activation_token.make_token(user),
})
to_email = form.cleaned_data.get('email')
email = EmailMessage(
mail_subject, message, to=[to_email]
)
email.send()
print(get_current_site(request))
# username = form.cleaned_data.get('username')
messages.success(request,f'Please confirm your email address to complete the registration')
return redirect('login')
else:
form = UserRegistrationForm()
return render(request,'users/register.html',{'form':form})
def create_user_acccount(request):
if request.method == 'POST':
form = UserRegistrationForm(request.POST)
if form.is_valid():
new_user = form.save(commit=False)
new_user.password = make_password(form.cleaned_data['password'])
new_user.username = form.instance.generic_username()
new_user.save()
try:
user = User.objects.get(email__exact=form.instance.email)
token = default_token_generator.make_token(user)
if user:
confirm_account_link(user,
form.instance.email,
token,
request=request)
return HttpResponseRedirect(
reverse('users:activation-sent'))
except User.DoesNotExist:
return HttpResponseRedirect(reverse('users:index'))
return HttpResponseRedirect(reverse('users:activation-sent'))
else:
form = UserRegistrationForm()
context = {
'form': form,
}
return render(request, 'users/registration.html', context)
def register(request):
error = 'None'
if request.method == 'POST':
user_form = UserRegistrationForm(request.POST)
if user_form.is_valid():
''' Begin reCAPTCHA validation '''
recaptcha_response = request.POST.get('g-recaptcha-response')
url = 'https://www.google.com/recaptcha/api/siteverify'
values = {
'secret': settings.GOOGLE_RECAPTCHA_SECRET_KEY,
'response': recaptcha_response
}
data = urllib.parse.urlencode(values).encode()
req = urllib.request.Request(url, data=data)
response = urllib.request.urlopen(req)
result = json.loads(response.read().decode())
''' End reCAPTCHA validation '''
if result['success']:
# Create a new user object but avoid saving it yet
new_user = user_form.save(commit=False)
# Set the chosen password
new_user.set_password(user_form.cleaned_data['password'])
# Save the User object
new_user.save()
return render(request, 'users/register_done.html', {'new_user': new_user})
else:
error = 'Invalid Captha'
else:
user_form = UserRegistrationForm()
context = {
'user_form': user_form,
'error': error,
}
return render(request, 'users/register.html', context)
