def post(self, request, *args, **kwargs):
form = UserRegistrationForm(request.POST)
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
user.save()
message_subject = "Activate your account"
domain_url = get_current_site(request)
user_email = form.cleaned_data["email"]
message = render_to_string(
"account/activation_message.html",
{
"domain": domain_url.domain,
"user": user,
"uid": urlsafe_base64_encode(force_bytes(user.id)),
"token": activation_token.make_token(user),
},
)
email = EmailMessage(message_subject, message, to=[user_email])
email.send()
activation_msg = "Open your email to activate account."
return render(
request, "account/activate_email.html", {"activation_msg": activation_msg}
)
template_name = "account/signup.html"
return render(request, template_name, {"form": form})
class register(TemplateView):
template_name = 'registration/register.html'
form = None
def get(self, request, *args, **kwargs):
self.form = UserRegistrationForm
return super(register, self).get(request, *args, **kwargs)
def get_context_data(self, **kwargs):
context = super(register, self).get_context_data(**kwargs)
context['form'] = self.form
return context
def post(self, request, *args, **kwargs):
self.form = UserRegistrationForm(request.POST)
if self.form.is_valid(
): #Если все поля заполнены правильно, то регистрируем пользователя и сразу же авторизовываем его
new_user = self.form.save(commit=False)
new_user.set_password(self.form.cleaned_data['password'])
new_user.save()
new_user.groups.add(Group.objects.get(name='simple_user')
) #Добавление в группу обычных пользователей
if new_user is not None:
if new_user.is_active:
login(request, new_user)
return redirect('index')
return super(register, self).get(request, *args, **kwargs)
def register_view(request):
reg_form = UserRegistrationForm(request.POST)
profile_form = ProfileForm(request.POST)
login_form = LoginForm()
if request.method == 'POST':
if reg_form.is_valid() and profile_form.is_valid():
new_user = reg_form.save(commit=False)
new_user_profile = profile_form.save(commit=False)
new_user.set_password(reg_form.cleaned_data['password'])
new_user.is_active = True
new_user.save()
new_user_profile.user = new_user
new_user_profile.save()
messages.success(request, 'Account created successfully!')
return redirect('index')
else:
messages.error(request, f'{reg_form.errors}')
return redirect('index')
else:
messages.error(request, 'Error registering, please try again.')
return redirect('index')
def post(self, request):
user_form = UserRegistrationForm(request.POST)
if user_form.is_valid():
new_user = user_form.save(commit=False)
new_user.set_password(user_form.cleaned_data['password'])
new_user.save()
return redirect("/login")
else:
return HttpResponse("Invalid data")
def test_form_with_valid_data(self):
form = UserRegistrationForm(
data={
'username': '******',
'first_name': 'borko',
'email': '*****@*****.**',
'password': '******',
'password2': '123'
})
self.assertTrue(form.is_valid())
def test_register_form_success():
form_data = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'pass123',
}
form = UserRegistrationForm(data=form_data)
assert form.is_valid() is True
def test_register_form_wrong_pass():
form_data = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'totalydifferentpassword'
}
form = UserRegistrationForm(data=form_data)
assert form.is_valid() is False
def register(request):
template = 'account/register.html'
if request.method == 'POST':
form = UserRegistrationForm(request.POST)
if form.is_valid():
new_user = form.save()
return HttpResponseRedirect(reverse('account:register_success'))
else:
form = UserRegistrationForm()
return render(request, template, {
'form': form,
})
def register(request):
if request.method == 'POST':
user_form = UserRegistrationForm(request.POST)
if user_form.is_valid():
new_user = user_form.save(commit=False)
new_user.set_password(user_form.cleaned_data['password'])
new_user.save()
profile = Profile.objects.create(user=new_user)
return render(request, 'account/register_done.html', {'new_user': new_user})
else:
user_form = UserRegistrationForm()
return render(request, 'account/register.html', {'user_form': user_form})
def user_register(request):
form = UserRegistrationForm(request.POST)
if form.is_valid():
#建立新数据对象但并不写入数据库
new_user = form.save(commit=False)
#验证两次输入的密码是否相同
password = form.clean_password2()
#将密码和其他信息一起存入数据库
new_user.set_password(password)
new_user.save()
Profile.objects.create(user=new_user)
create_action(new_user,'注册了账号')
return new_user
def registerPage(request, *args, **kwargs):
form = UserRegistrationForm(request.POST or None)
if form.is_valid():
user = form.save()
messages.success(request, 'Account was created for ' + user.username)
return redirect('login')
context = {
'form': form,
'url': 'login',
}
return render(request, 'blogapp/register.html', context)
def register(request):
if request.method == 'POST':
user_form = UserRegistrationForm(request.POST)
if user_form.is_valid():
new_user = user_form.save(commit=False)
new_user.set_password(user_form.cleaned_data['password'])
new_user.save()
Profile.objects.create(user=new_user)
return render(request, 'account/register_done.html', {
'new_user': new_user,
})
else:
if UserRegistrationForm.validate:
message = 'invalid username or email please try again!'
else:
message = 'unstable server'
user_form = UserRegistrationForm()
return render(request, 'account/register.html', {
'message': message,
'user_form': user_form
})
else:
user_form = UserRegistrationForm()
return render(request, 'account/register.html',
{'user_form': user_form})
def test_invalid_user_creation_form(db):
"""
GIVEN the data of a user with a wrong email adreess
WHEN UserRegistrationForm is given this data
THEN assert is_valid() returns False when it is called
"""
data = {
"username": "******",
"email": "mymail",
"password": "******",
"password": "******"
}
form = UserRegistrationForm(data)
assert form.is_valid() is False
def test_valid_user_creation_form(db):
"""
GIVEN the data of a valid user
WHEN UserRegistrationForm is given this data
THEN assert it returns True when is_valid() is called
"""
data = {
"username": "******",
"email": "*****@*****.**",
"password": "******",
"password2": "secret"
}
form = UserRegistrationForm(data)
assert form.is_valid() is True
def registration(request):
context = {}
param = simplejson.loads((str(request.GET['data'])).strip('/'))
param['redirect_after_reg'] = reverse('8800_connect')
context['data'] = simplejson.dumps(param)
form = UserRegistrationForm(request.GET)
context['form_reg'] = form
if form.is_valid():
action = param.get('action', '')
if form.cleaned_data['profile'] == 2:
user = form.save()
if action == "connect":
number_list = []
for number in param['numbers']:
external_number = ExternalNumber.objects.get(number = number)
bind_number(external_number, reserved = True, date = datetime.now(), user = user.id)
number_list.append(external_number.number)
param = {
'redirect_after_reg': reverse('8800_connect'),
'numbers': number_list,
'number800': action,
}
context['data'] = simplejson.dumps(param)
ActionRecord.registrations.create_inactive_user_key(
new_user = user,
#row_password = form.get_row_password(),
row_password = user.password,
send_email = True,
)
successfully_create = package(user, context['data'], reverse('8800_connect'))
elif action == "reservation":
account = profile.billing_account
now = datetime.now()
for number in param['numbers']:
external_number = ExternalNumber.objects.get(number = number)
group = create_group(profile, account)
bind_number(external_number, reserved = True, group = group, account = account, date = now)
create_zakaz(account, RESERVATION_SERVICE_TYPE, external_number, end_date = datetime.now() + relativedelta(days = 10))
return render_to_response("s8.html", { 'page': '8800/' })
if not successfully_create:
raise Http404
return render_to_response("s8_reg.html", context)
context['errors'] = { 'error_jur' : True }
return render_to_response("number800_reg.html", context)
else:
context['errors'] = { 'error_auth' : True }
return render_to_response("number800_reg.html", context)
def register(request):
if request.method == 'POST':
new_user = user_register(request)
return render(request, 'account/register_done.html',
{'new_user': new_user})
else:
form = UserRegistrationForm()
return render(request, 'account/register.html', {'user_form': form})
def test_different_passwords_user_creation_form(db):
"""
GIVEN the data of a user where passwords don't match
WHEN UserRegistrationForm is given this data
THEN assert it returns False when is_valid() is called
"""
data = {
"username": "******",
"email": "*****@*****.**",
"password": "******",
"password2": "secret2"
}
form = UserRegistrationForm(data)
assert form.is_valid() is False
def register(request):
if request.method == 'POST':
user_form = UserRegistrationForm(request.POST)
profile_form = ProfileRegistrationForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
try:
new_user = user_form.save(commit=False)
new_user.username = shortuuid.uuid(new_user.first_name + new_user.last_name)
new_profile = profile_form.save(commit=False)
new_user.set_password(user_form.cleaned_data['password'])
new_user.save()
new_profile.save()
Profile.objects.create(user=new_user, position=new_profile.position, post_code=new_profile.post_code)
return render(request, 'account/register_done.html', {'new_user': new_user})
except:
return render(request, 'account/register.html', {
'user_form': UserRegistrationForm(),
'profile_form': ProfileRegistrationForm(),
'error': True
})
else:
if request.session.has_key('username') and request.session.has_key('password'):
username = request.session['username']
password = request.session['password']
return redirect('account:profile')
user_form = UserRegistrationForm()
profile_form = ProfileRegistrationForm()
return render(request, 'account/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'error': False
})
def get(self, request):
"""
user register form
:param request:
"""
# render register page [if user is not give any post request]
return render(request, 'auth/register.html',
{'form': UserRegistrationForm()})
def post(self, request):
"""
user register form [post data user]
:param request:
"""
# get requested post form
form = UserRegistrationForm(request.POST or None)
# validate form
if form.is_valid():
# set datas variables
datas = {}
datas['email'] = form.cleaned_data['email']
datas['username'] = form.cleaned_data['username']
datas['password1'] = form.cleaned_data['password1']
# set username salt
username_salt = datas['username'].encode('utf-8')
# save user [account not verificated yet] bring some datas
user = form.save(datas)
user.is_valid = False
user.save()
# generate token
token = user_tokenizer.make_token(user)
# generate unique user-id
user_id = generate.set_user_id(user.id)
# create url activation
url = 'http://127.0.0.1:8000' + reverse('confirm-email',
kwargs={
'user_id': user_id,
'token': token
})
message = url
# email to user-email [new-user-account]
send_email_to(user.username, user.email, message)
# render login page after register, and give some message that user-account is not verificated yet
messages.warning(
request, f'A confirmation email has been sent to {user.email}')
return redirect('auth:login')
# register-form is not valid, return to register page
return render(request, 'auth/register.html',
{'form': UserRegistrationForm()})
def register(request):
if request.user.is_authenticated:
return redirect(reverse("dashboard"))
if request.method == 'POST':
user_form = UserRegistrationForm(data=request.POST)
if user_form.is_valid():
new_user = user_form.save(commit=False)
new_user.set_password(user_form.cleaned_data['password'])
new_user.save()
signature = Signature.objects.create(user=new_user)
profile = Profile.objects.create(
user=new_user,
date_of_birth=(date.today() -
timedelta(days=6574))) # 18 years
add_sendgrid_contact(new_user.email,
decouple.config("SENDGRID_LIST_ID"))
login(request, new_user)
return redirect(reverse("settings"))
else:
user_form = UserRegistrationForm
return render(request, 'account/register.html', {'user_form': user_form})
def register(request):
if request.method == 'POST':
user_form = UserRegistrationForm(request.POST)
profile_form = ProfileForm(request.POST)
if 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()
create_action(new_user, 'has created an account')
return render(request, 'account/register_done.html',
{'new_user': new_user})
else:
user_form = UserRegistrationForm()
profile_form = ProfileForm()
return render(request, 'account/register.html', {
'user_form': user_form,
'profile_form': profile_form,
})
def register(request):
if request.method == 'POST':
user_form = UserRegistrationForm(request.POST)
if user_form.is_valid():
new_user = user_form.save(commit=False)
new_user.set_password(user_form.cleaned_data['password'])
new_user.save()
Profile.objects.create(user=new_user)
new_user.save()
return render(
request,
'account/register_done.html',
{
'new_user': new_user,
},
)
return render(
request,
'account/registration.html',
{
'user_form': user_form,
},
)
else:
user_form = UserRegistrationForm()
return render(
request,
'account/registration.html',
{
'user_form': user_form,
},
)
def register(request):
""" обработчик регистрации пользователя """
if request.method == 'POST':
user_form = UserRegistrationForm(request.POST)
if user_form.is_valid():
new_user = user_form.save(commit=False)
new_user.set_password(user_form.cleaned_data['password'])
new_user.save()
Profile.objects.create(user=new_user)
cd = user_form.cleaned_data
user = authenticate(request, username=cd['username'], password=cd['password'])
if user is not None:
if user.is_active:
login(request, user)
subject = f"Регистрация на сайте 'Личная Бухгалтерия'"
message = f"Поздравляем, {cd['username']}! \nВы зарегистрированы!"
send_mail(subject, message, settings.EMAIL_HOST_USER, [cd['email']])
# send_mail_task.delay(cd['email'], cd['username'])
return HttpResponseRedirect(reverse('transfers-list'))
else:
return HttpResponse('Disabled account')
return HttpResponseRedirect(reverse('account:login'))
else:
messages.success(request, 'Ошибка создания пользователя')
else:
user_form = UserRegistrationForm()
return render(request, 'account/register.html', {'user_form': user_form})
def register(request):
if request.method == 'POST':
user_form = UserRegistrationForm(request.POST)
if user_form.is_valid():
# 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()
# Create the user profile
try:
return new_user.profile
except:
profile = Profile.objects.create(user=new_user)
return profile
#try:
# profile = request.user.profile
#except Profile.DoesNotExist:
# profile = Profile(user=request.user)
return render(request, 'account/register_done.html',
{'new_user': new_user})
else:
user_form = UserRegistrationForm()
return render(request, 'account/register.html', {'user_form': user_form})
def register(request):
#Регистрация пользователя
if request.method == 'POST':
user_form = UserRegistrationForm(request.POST)
profile_form = ProfileEditForm(request.POST)
if 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'])
new_user.save()
user = new_user,
profile = Profile.objects.create(
user=new_user,
Company=profile_form.cleaned_data['Company'],
Telephone=profile_form.cleaned_data['Telephone'],
Fax=profile_form.cleaned_data['Fax'],
Adress1=profile_form.cleaned_data['Adress1'],
Adress2=profile_form.cleaned_data['Adress2'],
City=profile_form.cleaned_data['City'],
State=profile_form.cleaned_data['State'],
Country=profile_form.cleaned_data['Country'],
Zip_code=profile_form.cleaned_data['Zip_code'])
profile.save()
return render(request, 'registration/register_done.html',
{'new_user': new_user})
else:
user_form = UserRegistrationForm()
profile_form = ProfileEditForm()
return render(request, 'registration/register.html', {
'user_form': user_form,
'profile_form': profile_form
})
def register_user(request):
if request.method == 'POST':
form = UserRegistrationForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
if cd['password'] == cd['repeat_password']:
new_user = form.save(commit=False)
new_user.set_password(cd['password'])
new_user.save()
Profile.objects.create(user=new_user)
context = {'new_user': new_user}
messages.success(request, 'Your Profile has been created')
return render(request, 'account/register_done.html', context)
else:
raise forms.ValidationError("Passwords don't match")
else:
messages.error(request, 'Error in input data.')
form = UserRegistrationForm()
context = {'form': form}
return render(request, 'account/registration.html', context)
def register(request):
if request.method == 'POST':
form = UserRegistrationForm(request.POST)
if form.is_valid():
new_user = form.save(commit=False)
new_user.set_password(form.cleaned_data['password'])
new_user.save()
return redirect(reverse('account:login'))
else:
form = UserRegistrationForm()
return render(request, 'account/register.html', {'form': form})
def register(request):
template = 'account/register.html'
if request.method == 'POST':
form = UserRegistrationForm(request.POST)
if form.is_valid():
new_user = form.save()
return HttpResponseRedirect(reverse('account:register_success'))
else:
form = UserRegistrationForm()
return render(request, template, {
'form': form,
})
def register(request):
if request.method == 'POST':
user_form = UserRegistrationForm(request.POST)
if user_form.is_valid():
new_user = user_form.save(commit=False)
new_user.set_password(user_form.cleaned_data['password'])
new_user.save()
Profile.objects.create(user=new_user)
return redirect('login')
else:
user_form = UserRegistrationForm()
return render(request, 'register.html')
def index_view(request):
registration_form = UserRegistrationForm()
profile_form = ProfileForm()
login_form = LoginForm()
if request.user.is_authenticated:
reservations = request.user.reservations.all()
vehicles = Vehicle.objects.all().exclude(
id__in=[vehicle.id for vehicle in reservations])
else:
vehicles = Vehicle.objects.all()
context = {
'registration_form': registration_form,
'profile_form': profile_form,
'login_form': login_form,
'vehicles': vehicles,
'html_title': 'WELCOME TO CARTAL',
}
return render(request, 'index.html', context)
def register(request):
if request.method == "POST":
user_form = UserRegistrationForm(request.POST)
if user_form.is_valid():
new_user = user_form.save(commit=False)
new_user.set_password(user_form.cleaned_data["password"])
new_user.save()
Profile.objects.create(user=new_user)
return render(request, "account/register_done.html",
{"new_user": new_user})
user_form = UserRegistrationForm()
return render(request, "account/register.html", {"user_form": user_form})
def register(request):
if 'POST' == request.method:
user_form = UserRegistrationForm(request.POST)
if user_form.is_valid():
new_user = user_form.save(commit=False)
new_user.set_password(user_form.cleaned_data['password'])
new_user.save()
return render(request, 'account/register_done.html',
{'new_user': new_user})
else:
user_form = UserRegistrationForm()
return render(request, 'account/register.html', {'user_form': user_form})
def panel_base_auth(request, context):
class TopErrors(object):
def __init__(self):
self._errors = []
def add(self, error):
self._errors.append(u'<li>%s</li>' % error)
def render(self):
if self._errors:
return u'<ul class="errorlist">%s</ul>' % '\n'.join(self._errors)
return u''
if not context.has_key('objects'):
context['news_win'] = True
from content.views import content_list_base
news = content_list_base(request, News_Moscowhost, 4)
context.update(news)
else:
context['news_win'] = False
top_errors = TopErrors()
form_login = UserLoginForm2()
form_reg = UserRegistrationForm()
form_reset = PasswordResetRequestForm()
if request.user.is_anonymous():
if 'login_m' in request.POST or 'registr' in request.POST or 'reset_password' in request.POST:
if request.POST:
if 'login_m' in request.POST:
form_login = UserLoginForm2(request.POST)
if form_login.is_valid():
user = form_login.user
if user:
if user.is_active:
_login(request, user)
return HttpResponseRedirect(redirect(request, next_only=get_base_url(user)))
else:
try:
action = ActionRecord.objects.get(user=user, type='A')
except:
action = None
if not action or action.expired:
context.update({'not_active' : True})
context['panel'] = True
top_errors.add(u'''
Учётная запись не активирована.
Возможно, Вы не прошли по ссылке в письме,
присланном Вам после регистрации.
<br/>
Если Вы не получали письма, или код активации просрочен, Вы можете
<a class="bold" href="%s?user=%s">получить код активации заново</a>.
''' % (reverse('resend_activation_code'), form_login.cleaned_data['username']))
else:
context.update({'error_login' : True})
context['login_er'] = True
if 'registr' in request.POST:
form_reg = UserRegistrationForm(request.POST)
if form_reg.is_valid():
user = form_reg.save()
action_key, send_mail = ActionRecord.registrations.create_inactive_user_key(# @UnusedVariable
new_user=user,
#row_password=form_reg.get_row_password(),
row_password = user.password,
send_email=True,
)
context.update({'reg_compite' : True})
#context['reg_er'] = True //не выводим окно если рег успешна
else:
context['reg_er'] = True
if 'reset_password' in request.POST:
form_reset = PasswordResetRequestForm(request.POST)
if form_reset.is_valid():
user = form_reset.user
if user and user.is_active:
ActionRecord.resets.create_password_reset([user])
context['reset_password_success'] = u'Письмо с инструкциями по смене пароля было выслано Вам по электронной почте.'
else:
context['reset_password_error'] = u'Пользователя с указанным именем не существует!'
context['reset_er'] = True
else:
form_login = UserLoginForm2()
form_reg = UserRegistrationForm()
form_reset = PasswordResetRequestForm()
# log.add("showing user registration page")
context['form_login'] = form_login
context['form_reset'] = form_reset
context['top_errors'] = top_errors.render()
context['form_reg'] = form_reg
'''
from reviews.views import write_review
if (request.path_info != '/' and request.path_info != ''):
context.update(write_review(request))
'''
context['user_name'] = request.user.username
context['left_block'] = get_left_block()
#from hotspot.views import hotspot_identity
#context['site'] = settings.CURRENT_SITE
context['article_page_on_hotspot'] = True
#context.update(hotspot_identity(request))
return context
