def test_signup_dataprotection_confirmation_required(self):
# no policy yet, no need to confirm
assert DataPrivacyPolicy.objects.exists() is False
form_data = {**self.base_form_data, 'data_privacy_confirmation': False}
form = SignupForm(data=form_data)
assert form.is_valid()
baker.make(DataPrivacyPolicy)
form_data = {**self.base_form_data, 'data_privacy_confirmation': False}
form = SignupForm(data=form_data)
assert form.is_valid() is False
def test_must_be_over_16(self):
form_data = {
**self.base_form_data,
'date_of_birth':
(timezone.now() - timedelta(360 * 16)).strftime("%d-%b-%Y"),
}
form = SignupForm(data=form_data)
assert form.is_valid() is False
form_data = {
**self.base_form_data,
'date_of_birth':
(timezone.now() - timedelta(366 * 16)).strftime("%d-%b-%Y"),
}
form = SignupForm(data=form_data)
assert form.is_valid() is True
def frontpage(request):
if request.user.is_authenticated:
return redirect("/" + "profile.html" + "/")
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 = SigninForm()
if signinform.is_valid():
login(request, signinform.get_user())
return redirect("/")
else:
signupform = SigninForm()
signinform = SigninForm()
return render(request, "frontpage.html", {"signupform": signupform, "signinform": signinform})
def test_invalid_password_confirm(self):
"""Test when the password confirm field is invalid"""
data = self.data
data['password2'] = 'p4ssword_2'
form = SignupForm(data)
assert form.is_valid() is False, \
'The form should be invalid with invalid second password'
def test_SignupForm_not_valid_missing_email(self):
form = SignupForm(data={
'first_name': 'teo',
'email': '*****@*****.**',
'phone': '0111111111'
})
self.assertFalse(form.is_valid())
def signup(request):
regist_terms=Texts.objects.get(name="regist_terms")
privacy_info_terms=Texts.objects.get(name="privacy_info_terms")
if request.method=="POST":
userform = SignupForm(request.POST)
if userform.is_valid():
user = userform.save(commit=False)
user.username = userform.cleaned_data['username']
user.save()
profile = Profile(user=user)
profile.save()
return HttpResponseRedirect(reverse("signup_ok"))
return render(request, "accounts/signup.html", {
'userform': userform,
'message':'입력정보를 정확히 확인해주세요.',
'regist_terms':regist_terms.contents,
'privacy_info_terms':privacy_info_terms.contents,
})
elif request.method=="GET":
userform = SignupForm()
return render(request, "accounts/signup.html", {
'userform':userform,
'message':'첫 화면',
'regist_terms':regist_terms.contents,
'privacy_info_terms':privacy_info_terms.contents,
})
def test_invalid_email(self):
"""Test when data has an invalid email"""
data = self.data
data['email'] = 'EMAIL'
form = SignupForm(data)
assert form.is_valid() is False, \
'The form should be invalid with invalid email'
def post(self, request, *args, **kwargs):
form = SignupForm(data=request.POST or None)
response_data = {}
if form.is_valid():
user_name = request.POST['user_name']
password = request.POST['password']
password_confirm = request.POST['password_confirm']
email = request.POST['email']
if password_confirm == password:
new_user = User(user_name=user_name, email=email)
new_user.set_password(password)
new_user.save()
# print('user_id',new_user.id)
response_data['success'] = 'yes'
response_data['success_msg'] = 'Successfully signed up'
login(request, new_user)
# return redirect('/home/')
else:
# print('password_confirm !== password')
response_data['success'] = 'no'
response_data['success_msg'] = 'password dont match'
else:
# print('form is not valid',form.errors)
response_data['success'] = 'no'
response_data['success_msg'] = 'form not valid'
return JsonResponse(response_data)
def post(self, request, encoded_email, encrypted_hash):
encoded_email = encoded_email.replace("slash", "/")
data = {}
for key, value in request.POST.items():
data[key] = value
# disabled fields are ignored by django forms
data["email"] = decode_data(
config("SIGNUP_EMAIL_ENCODING_SECRET"), encoded_email
).decode("utf-8")
form = SignupForm(data)
if form.is_valid():
form.save()
username = form.cleaned_data.get("username")
password = form.cleaned_data.get("password1")
user = authenticate(username=username, password=password)
login(request, user)
return redirect("after_login")
else:
return render(
request,
self.template,
{"form": form, "email": form.cleaned_data.get("email")},
)
def signup(request):
"""
Отображение формы регистрации пользователя / регистрация пользователя
:param request:
:return:
"""
# Для авторизованных пользователей регистрация недоступна
if request.user.is_authenticated():
return HttpResponseRedirect(reverse('products:index'))
signup_form = SignupForm(request.POST or None)
if request.method == 'POST':
if not signup_form.is_valid():
if signup_form.username_not_unique:
return render(
request, 'accounts/signup.html', {
'form': signup_form,
'usernames': unique_username(request.POST['username'],
5)
})
return render(request, 'accounts/signup.html',
{'form': signup_form})
# Регистрируем пользователя
user, password = register_user(request,
signup_form.cleaned_data['email'],
signup_form.cleaned_data['username'],
signup_form.cleaned_data['password'])
send_registration_email(user, password)
return HttpResponseRedirect(reverse('accounts:profile'))
if request.method == 'GET':
return render(request, 'accounts/signup.html', {'form': signup_form})
def signup(request):
"""
backend for signup, sends activation mail to user
This view is linked with phdadmission/accounts/templates/accounts/signup.html
"""
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user_email = request.POST['email']
user = form.save(commit=False)
user.is_active = False
user.username = user_email
user.save()
current_site = get_current_site(request)
message = render_to_string(
'acc_active_email.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': account_activation_token.make_token(user),
})
mail_subject = 'Activate your IIT Ropar PhD Portal account.'
to_email = form.cleaned_data.get('email')
email = EmailMessage(mail_subject, message, to=[to_email])
email.send()
return HttpResponse(
'Please confirm your email address to complete the registration. To login go back to Homepage'
)
else:
form = SignupForm()
return render(request, 'accounts/signup.html', {'form': form})
def test_SignupForm_not_valid_missing_phone(self):
form = SignupForm(data={
'first_name': 'teo',
'last_name': 'budeanu',
'email': '*****@*****.**'
})
self.assertFalse(form.is_valid())
def signup(request):
if request.method == 'POST':
form = SignupForm(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 = '[Zinzi] 이메일 인증'
html_message = render_to_string('user_activate.html', {
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.pk)),
'token': urlsafe_base64_encode(force_bytes(user.token)),
})
to_email = form.cleaned_data['email']
email = EmailMultiAlternatives(
mail_subject,
html_message,
to=[to_email],
)
email.attach_alternative(html_message, 'text/html')
email.send()
return HttpResponse('이메일 인증을 위해 이메일을 확인해주십시오.')
else:
form = SignupForm()
return render(request, 'accounts/signup.html', {'form': form})
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
# backend_cls = get_backends()[0].__class__
# backend_path = backend_cls.__module__ + '.' + backend_cls.__name__
# https://github.com/django/django/blob/1.9/django/contrib/auth/__init__.py#L81
# user.backend = backend_path
authenticated_user = authenticate(
username=form.cleaned_data['username'],
password=form.cleaned_data['password1'])
auth_login(request, authenticated_user)
messages.info(request, '환영합니다. ;)')
return redirect(settings.LOGIN_REDIRECT_URL)
# 회원가입 시에, 이메일 승인
# user = form.save(commit=False)
# user.is_active = False
# user.save()
# send_signup_confirm_email(request, user)
# return redirect(settings.LOGIN_URL)
else:
form = SignupForm()
return render(request, 'accounts/signup.html', {
'form': form,
})
def register(request): # ou appeler signin
if request.method == 'POST': # save
form = SignupForm(request.POST)
if form.is_valid(): # si valide alors save
user = form.save(commit=False) # save le new user mais sans login
user.is_active = False
user.save()
site = get_current_site(request)
mail_subject = 'confirmation message for foueds site '
message = render_to_string(
'accounts/registration/confirm_email.html', {
'user': user,
'domain': site.domain,
'uid': user.id,
'token': activation_token.make_token(user)
})
to_email = form.cleaned_data.get('email')
to_list = [to_email]
from_email = settings.EMAIL_HOST_USER
recipient_list = [to_email]
send_mail(mail_subject,
message,
from_email,
recipient_list,
fail_silently=True)
return redirect('/accounts/register/activate_mail_sent')
else: # show form
form = SignupForm()
return render(request, 'accounts/registration/register.html',
{'form': form})
def signup_view(request):
if request.method == "POST": # Check if it is a POST request
form = SignupForm(request.POST) # Pass the data from the POST request
# Check if the form is valid
if form.is_valid():
# Save the user's data to the database
user = form.save(
commit=False) # Wait until the user has confirmed their email
user.last_login = timezone.now() # Update the last login field
user.is_active = False
user.save()
# Send a confirmation email to the user
to_email = form.cleaned_data.get("email")
csrf_token = get_token(request)
current_site = get_current_site(request).domain
path = str(reverse_lazy("accounts:send-activate-account-email"))
confirm_email_url = "http://" + current_site + path
try:
requests.post(
confirm_email_url,
data={
"csrfmiddlewaretoken": csrf_token,
"to_email": to_email
},
cookies={
"csrftoken": csrf_token
}) # Sends a request to the confirmation email page
except requests.exceptions.ConnectionError as e:
if confirm_email_url[7:17] == "testserver":
# This is a test; ignore any errors that may arise
pass
else:
raise e
# Report to the log that a user has just signed up
logger.info(
f"A new user '{User.objects.get(email=to_email).username}' just signed up."
)
# Redirect user to the "please confirm your email" page
return render(
request, "accounts/webpages/account_activation.html", {
"page_type": "confirm email",
"confirm_email_url": confirm_email_url,
"email_address": to_email
})
else:
logger.info("A person tried to sign up but checks failed.")
else: # This is a GET request
form = SignupForm() # Define a user creation form
return render(request, "accounts/webpages/signup.html",
{"form": form}) # Send the form to the template
def test_with_clean_data(self):
data = {
'username': self.username,
'email': self.email,
'password': self.password
}
form = SignupForm(data=data)
self.assertTrue(form.is_valid())
def test_already_exist_email(self):
data = {
'username': self.username,
'email': self.already_exist_email,
'password': self.password
}
form = SignupForm(data=data)
self.assertFalse(form.is_valid())
def test_signup_form_with_invalid_data(self):
# first_name must have 30 characters or fewer
form_data = {
**self.base_form_data,
'first_name': 'abcdefghijklmnopqrstuvwxyz12345',
}
form = SignupForm(data=form_data)
assert form.is_valid() is False
def test_without_email(self):
data = {
'username': self.username,
'email': None,
'password': self.password
}
form = SignupForm(data=data)
self.assertFalse(form.is_valid())
def test_signup_form_with_invalid_data(self):
# first_name must have 30 characters or fewer
form_data = {
'first_name': 'abcdefghijklmnopqrstuvwxyz12345',
'last_name': 'User'
}
form = SignupForm(data=form_data)
self.assertFalse(form.is_valid())
def test_SignupForm_valid(self):
form = SignupForm(
data={
'first_name': 'teo',
'last_name': 'budeanu',
'email': '*****@*****.**',
'phone': '0111111111'
})
self.assertTrue(form.is_valid())
def post(self, request):
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return redirect('home')
return render(request, 'signup.html', {'form':form})
def test_invalid_email(self):
for email in self.invalid_emails:
data = {
'username': self.username,
'email': email,
'password': self.password
}
form = SignupForm(data=data)
self.assertFalse(form.is_valid())
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
auth_login(request, user)
return redirect('home')
else:
form = SignupForm()
return render(request, 'signup.html', {'form': form})
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('home'))
else:
form = SignupForm()
args = {'form': form}
return render(request, 'accounts/signup.html', args)
def signup(request):
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
profile = user.get_profile()
profile.nickname = request.POST.get('nickname')
profile.save()
user_dict = model_to_dict(user, fields=['id', 'username'])
return JsonResponse(user_dict)
return JsonResponse(form.errors)
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST, request.FILES)
if form.is_valid():
user = form.save()
django_login(request, user) # 로그인 처리
return redirect(settings.LOGIN_URL)
else:
form = SignupForm()
return render(request, 'accounts/signup_form.html', {'form': form,})
def signup_view(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
login(request, user)
return redirect('index')
else:
form = SignupForm()
return render(request, 'accounts/signup.html', {'form': form})
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return redirect(settings.LOGIN_URL)
else:
form = SignupForm()
return render(request, 'accounts/signup.html', {
'form': form,
})
def signup(request):
if request.method == 'POST':
form = SignupForm(request, data=request.POST)
if form.is_valid():
form.save()
return redirect('accounts.signup_done')
else:
form = SignupForm(request)
return render(request, 'accounts/signup.j.html', {
'form': form
})
def signup(request):
""" User signup view that uses the SignupForm with the location field. """
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
auth_login(request, user)
return redirect('dashboard')
else:
form = SignupForm()
return render(request, 'open-pages/signup.html', {'form': form})
def test_able_to_signup(self):
# print(User.objects.all())
form = SignupForm(data={
'email': '*****@*****.**',
'password': '******',
'password2': 'aloc'
})
# print(form)
self.assertTrue(form.is_valid())
user = form.save()
self.assertIn(user, User.objects.all())
def signup(request):
if request.method== 'POST':
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return redirect(settings.LOGIN_URL)
else:
form = SignupForm()
return render(request, 'accounts/signup.html', {
'form':form,
})
def signup(request):
if request.method =="POST":
form = SignupForm(request.POST)
if form.is_valid():
form.save()
return redirect('/')
else:
form = SignupForm()
return render(request, 'accounts/signup.html',{
'form':form
})
def test_user_assigned_from_request(self):
user = mommy.make(User)
url = reverse('account_signup')
request = self.factory.get(url)
request.user = user
form_data = {'first_name': 'New',
'last_name': 'Name'}
form = SignupForm(data=form_data)
self.assertTrue(form.is_valid())
form.signup(request, user)
self.assertEquals('New', user.first_name)
self.assertEquals('Name', user.last_name)
def signup(request):
uform = SignupForm(request.POST or None, request.FILES or None)
if uform.is_valid():
user = uform.save()
user.backend = "django.contrib.auth.backends.ModelBackend"
auth_login(request, user)
next_url = request.GET.get("next", "/timeline")
return redirect(next_url)
else:
params = {"uform": uform}
return render(request, "accounts/signup.html", params)
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, 'Successfully registered!')
next_url = request.GET.get('next', 'blog:index')
return redirect(next_url)
else:
form = SignupForm()
return render(request, 'form.html', {
'form': form,
})
def signup(request):
if request.method == 'POST':
signupField = SignupForm(request.POST)
if signupField.is_valid():
signupField.save()
# next_url = request.GET.get('next', '')
# return redirect(settings.LOGIN_URL + '?next=' + next_url)
return redirect(reverse('blog:list') + '?complete')
else:
signupField = SignupForm()
return render(request, 'accounts/signup.html', {
'viewModel' : signupField,
})
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
# form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
return redirect('/')
#return render(request, 'accounts/profile.html')
#return render(request, 'accounts/login.html')
#return render(request, '/index.html')
else:
form = SignupForm()
return render(request, 'accounts/signup.html' , {'form': form,
})
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
backend_cls = get_backends()[0].__class__
backend_path = backend_cls.__module__+ '.' + backend_cls.__name__
user.backend = backend_path
auth_login(request, user)
messages.info(request, '환영합니다.')
return redirect(settings.LOGIN_REDIRECT_URL)
else:
form = SignupForm()
return render(request, 'accounts/signup.html', {'form': form,})
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, '회원가입 되었습니다.')
next_url = request.GET.get('next', 'blog:index') # url reverse 기능
return redirect(next_url)
else:
form = SignupForm()
return render(request, 'form.html', {
'form': form,
})
def signup(request):
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
user = form.save()
user.backend = "django.contrib.auth.backends.ModelBackend"
auth_login(request, user)
messages.success(request, "{} 님. 이메일을 확인해주세요.".format(user))
next_url = request.GET.get("next", "/")
return redirect(next_url)
else:
form = SignupForm()
return render(request, "accounts/go.html", {"form": form})
def signup(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, '회원가입 되었습니다.')
# next_url = request.GET.get('next', 'blog.views.index')
next_url = reverse("django.contrib.auth.views.login") + "?next="
+ request.GET.get("next", "") # 가입 후 로그인 들렀다가 redirect
return redirect(next_url)
else:
form = SignupForm()
return render(request, 'form.html', {
'form': form,
})
def signup(request, template_name='accounts/signup.html'):
signup_form = SignupForm(request.POST or None)
user_profile_signup_form = UserProfileSignupForm(request.POST or None, request.FILES or None)
if request.method == 'POST':
if signup_form.is_valid() and user_profile_signup_form.is_valid():
with transaction.atomic():
user = signup_form.save()
user_profile = user_profile_signup_form.save(commit=False)
user_profile.user = user
user_profile.save()
redirect_to = reverse('accounts:user_list')
return HttpResponseRedirect(redirect_to)
context = {
'signup_form': signup_form,
'user_profile_signup_form': user_profile_signup_form
}
return TemplateResponse(request, template_name, context)
def signup(request):
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
# user = form.save(commit=False)
# user.is_active = False
# user.save()
# send_signup_confirm_email(request, user)
# return redirect(settings.LOGIN_URL)
user = form.save()
backend_cls = get_backends()[0].__class__
backend_path = backend_cls.__module__ + "." + backend_cls.__name__
user.backend = backend_path
auth_login(request, user)
messages.info(request, "Welcome")
return redirect(settings.LOGIN_REDIRECT_URL)
else:
form = SignupForm()
return render(request, "accounts/signup.html", {"form": form})
def signup(request):
if request.method == "POST":
form = SignupForm(request.POST)
if form.is_valid():
form.save()
username = form.cleaned_data['username']
email = form.cleaned_data['email']
token = str(uuid4())
key_expires = datetime.datetime.today() + datetime.timedelta(2)
User = get_user_model()
user = User.objects.get(username=username)
email_token = UserProfile(user=user, token=token, key_expires=key_expires)
email_token.save()
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, token)
send_mail(email_subject, email_body, '*****@*****.**', [email], fail_silently=False)
messages.success(request, '이메일이 전송되었습니다. 이메일 인증 후 아이디 사용이 가능합니다.')
return HttpResponseRedirect('/accounts/signup/complete')
# return HttpResponseRedirect('/')
# return redirect(settings.LOGIN_URL)
else:
form = SignupForm()
tokens= {}
tokens.update(csrf(request))
tokens['form'] = form
return render(request, 'accounts/signup.html', tokens)
def test_signup_form(self):
form_data = {'first_name': 'Test',
'last_name': 'User'}
form = SignupForm(data=form_data)
self.assertTrue(form.is_valid())
def signup(request):
form = SignupForm(request.POST or None)
if form.is_valid():
username = form.cleaned_data['email']
password = form.cleaned_data['password']
first_name = form.cleaned_data['first_name']
last_name = form.cleaned_data['last_name']
email = form.cleaned_data['email']
next = request.POST.get('next', '')
# check for duplicate username/email
try:
user = User.objects.get(username=username)
messages.error(request, "Whoops, this user exists already. Did you forget your password?")
# whoops user exists
return HttpResponseRedirect(reverse("signup"))
except:
user = User.objects.create_user(
username=username,
password=password,
first_name=first_name,
last_name=last_name,
email=email
)
user = authenticate(username=username, password=password)
# don't log them in.
login(request, user)
next = request.GET.get('next', '')
messages.success(request, "Thank you, you've successfully signed up for an account! You are now logged in")
if next:
# here is where signup happened mid-buy. make sure recips get tagged with user.
the_cart_id = request.session['cart_id']
cart = Cart.objects.get(id=the_cart_id)
print "we have a cart mid buy"
subbies = CartItem.subbie_type.filter(cart=cart)
order = Order.objects.get(cart=cart)
print order
if subbies:
for sub in subbies:
recip = sub.recipient
print recip
if recip is not None:
print "we got recip in a sub"
recip.user = user
recip.save()
else:
pass
main_recipient = order.main_recipient
if main_recipient is not None:
main_recipient.user = user
print main_recipient
main_recipient.save()
else:
pass
return HttpResponseRedirect(next)
else:
return HttpResponseRedirect(settings.LOGIN_REDIRECT_URL)
context = {
"form": form,
}
template = "accounts/signup.html"
return render(request, template, context)
def test_signup_form_with_invalid_data(self):
# first_name must have 30 characters or fewer
form_data = {'first_name': 'abcdefghijklmnopqrstuvwxyz12345',
'last_name': 'User'}
form = SignupForm(data=form_data)
self.assertFalse(form.is_valid())
