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 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():
form = SignupForm()
if form.validate_on_submit():
form.save()
flash(u'Check your email to confirm registration.', 'success')
return redirect(url_for('pages_app.index'))
return render_template('accounts/signup.html', form=form)
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 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 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 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):
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_SignupForm_not_valid_missing_phone(self):
form = SignupForm(data={
'first_name': 'teo',
'last_name': 'budeanu',
'email': '*****@*****.**'
})
self.assertFalse(form.is_valid())
def test_SignupForm_not_valid_missing_email(self):
form = SignupForm(data={
'first_name': 'teo',
'email': '*****@*****.**',
'phone': '0111111111'
})
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_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_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_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_without_email(self):
data = {
'username': self.username,
'email': None,
'password': self.password
}
form = SignupForm(data=data)
self.assertFalse(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_SignupForm_valid(self):
form = SignupForm(
data={
'first_name': 'teo',
'last_name': 'budeanu',
'email': '*****@*****.**',
'phone': '0111111111'
})
self.assertTrue(form.is_valid())
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():
form = SignupForm()
if form.validate_on_submit():
form.save()
flash(
u'Successfully registered',
'success'
)
return redirect(url_for('accounts_app.login'))
return render_template('accounts/signup.html', form=form)
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():
form = SignupForm()
if form.validate_on_submit():
form.save()
flash(
u'Check your email to confirm registration.',
'success'
)
return redirect(url_for('pages_app.index'))
return render_template('accounts/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('/')
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 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):
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 test_recaptcha_debug(self):
form = SignupForm({
'email': '*****@*****.**',
'username': '******',
'password1': 'aaaaaaaa',
'password2': 'aaaaaaaa',
'consent': True,
})
with self.settings(DEBUG=True):
self.assertTrue(form.is_valid())
def test_recaptcha(self):
form = SignupForm({
'email': '*****@*****.**',
'username': '******',
'password1': 'aaaaaaaa',
'password2': 'aaaaaaaa',
'consent': True,
})
self.assertFalse(form.is_valid())
self.assertEquals(form.cleaned_data['email'], form.cleaned_data['username'])
self.assertEquals(list(form.non_field_errors())[0], "reCaptcha should be validate")
def test_sign_up_normal_user(self):
"""SignupForm: 正常値"""
# form
params = {'username': '******' * 150, 'password': '******' * 128}
form = SignupForm(params)
# assert form validation
self.assertTrue(form.is_valid())
# response
path = reverse('accounts:signup')
response = self.client.post(path, params)
# assert http status
self.assertEqual(response.status_code, 302)
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':
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':
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)
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):
template = 'signup.html'
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
form.save()
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:
form = SignupForm
return render(request, template, {'form':form})
def signup(request):
signup_form = SignupForm(request.POST or None)
profile_form = ProfileForm(request.POST or None, request.FILES or None)
if request.method == "POST":
if signup_form.is_valid() and profile_form.is_valid():
user = signup_form.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
return redirect(reverse('main:showMain'))
return render(request, 'accounts/signup.html', {
'signup_form': signup_form,
'profile_form': profile_form,
})
def assert_form_data(usernames=['u' * 150], passwords=['p' * 128]):
for name in usernames:
for password in passwords:
# form
params = {'username': name, 'password': password}
form = SignupForm(params)
# assert validation
self.assertFalse(form.is_valid())
# response
path = reverse('accounts:signup')
response = self.client.post(path, params)
# assert http status
self.assertEqual(response.status_code,
200) # redirect to SignUp form
def signup(request):
form = SignupForm(request.POST or None)
if form.is_valid():
form.save()
username = form.cleaned_data.get('email')
password = form.cleaned_data.get('password')
user = auth.authenticate(username=username, password=password)
redirect_url = 'login'
if user:
auth.login(request, user)
redirect_url = settings.LOGIN_REDIRECT_URL
return redirect(redirect_url)
ctx = {'form': form}
return TemplateResponse(request, 'accounts/signup.html', ctx)
def signup(request):
username = ''
password = ''
re_password = ''
true_name = ''
department = ''
position = ''
errors = ''
if request.method == 'POST':
signupForm = SignupForm(request.POST)
if signupForm.is_valid():
username = signupForm.cleaned_data['username']
password = signupForm.cleaned_data['password']
re_password = signupForm.cleaned_data['re_password']
true_name = signupForm.cleaned_data['true_name'] # 姓名
department = signupForm.cleaned_data['department'] # 部门
position = signupForm.cleaned_data['position'] # 职位
if password != re_password:
errors = '两次输入的密码不一致'
return render(request, 'signup.html', {'errors': errors})
filterResult = User.objects.filter(username=username)
if len(filterResult) > 0:
errors = '该用户已经存在'
return render(request, 'signup.html', {'errors': errors})
user = User()
user.username = username
user.set_password(password)
user.save()
userProfile = UserProfile()
userProfile.user_id = user.id
userProfile.true_name = true_name
userProfile.department = department
userProfile.position = position
userProfile.save()
newUser = auth.authenticate(username=username, password=password)
if newUser is not None:
login(request, newUser)
return render(request, 'index_base.html', {'username': username})
# return HttpResponse('注册成功') 测试代码
else:
return render(request, 'signup.html', {'form': signupForm})
# 如果不是提交数据，返回空白的注册表单
else:
signupForm = SignupForm()
return render(request, 'signup.html')
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 get(self, request, encoded_email, encrypted_hash):
encrypted_hash = encrypted_hash.replace("slash", "/")
encoded_email = encoded_email.replace("slash", "/")
# verify link authenticity
if not check_data(config("SIGNUP_EMAIL_PHRASE"), encrypted_hash):
messages.error(request, "Invalid link")
return redirect("signup")
email = decode_data(
config("SIGNUP_EMAIL_ENCODING_SECRET"), encoded_email
).decode("utf-8")
# check if email is already used
if CustomUser.objects.filter(email=email).exists():
messages.info(
request,
'This email is already in use. Login <a href="'
+ reverse("login")
+ '">here</a>.',
)
return redirect("signup")
form = SignupForm(initial={"email": email})
return render(request, self.template, {"form": form, "email": email})
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 register(request):
if request.method == 'POST':
form = SignupForm(request.POST)
if form.is_valid():
user = User.objects.create_user(**form.cleaned_data)
messages.info(request, f"Successfully created user: {user.username}")
login(request, user)
return redirect(reverse('accounts:edit-profile'))
messages.error(request, 'Invalid input: Please fix the appropriate fields and try again.')
else:
form = SignupForm()
return render(request, 'registration/signup.html', {
'form': form
})
def test_alpha_validator_no_error(self):
"""
Tests the alphanumeric validator for fields when there is no error
"""
form = SignupForm({'first_name': 'David'})
assert "Este campo solo permite letras" \
not in form.errors
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, 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():
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_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_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)
