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_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 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 register_view(request):
form = UserCreationForm()
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('accounts:login'))
return render(request, 'register.html', {'form': form})
def register(request):
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('login'))
else:
return render(request, 'accounts/register.html',
{'form': UserCreationForm(), 'error': 'Napaka, poskusite znova. Pozorni bodite na geslo!'})
return render(request, 'accounts/register.html', {'form': UserCreationForm()})
def register_view(request):
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
return redirect('login_url')
else:
form = UserCreationForm()
return render(request, 'registration/register.html', {'form': form})
def testUserForm(request):
if request.method == "POST":
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
return JsonResponse({"result": 'success'}, safe=False)
else:
data = json.loads(form.errors.as_json())
return JsonResponse({"errors": data}, status=400, safe=False)
form = UserCreationForm()
return render(request, "test.html", {"form": form})
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 register(request):
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, f'You can log in now')
return redirect('shop:shop-home')
else:
form = UserCreationForm()
return render(request, 'shop/registration.html', {'form': form})
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 register(request):
if request.method == "POST":
form = UserCreationForm(request.POST)
print("wait")
if form.is_valid():
print("yes")
#update_session_auth_hash(request,form.user)
form.save()
return redirect('/account')
else:
form = UserCreationForm()
args = {'form': form}
return render(request, 'accounts/register1.html',
args) #Changed name from reg_html to register1
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,
})
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 create_paperboy(request):
if request.method == "POST":
form = PaperBoyForm(request.POST)
uform = UserCreationForm(request.POST)
branch_obj = request.user.manager.branch
if form.is_valid() and uform.is_valid():
user_obj = uform.save(commit=False)
user_obj.user_type = 'paperboy'
user_obj.save()
paper_boy_obj = form.save(commit=False)
paper_boy_obj.branch = branch_obj
paper_boy_obj.user = user_obj
paper_boy_obj.save()
messages.success(request, "PaperBoy created successfully")
return redirect('manager:index')
else:
errors = uform.errors.as_data()
for key in errors:
error_list = errors[key][0]
for i in error_list:
messages.success(request, i)
errors = form.errors.as_data()
for key in errors:
error_list = errors[key][0]
for i in error_list:
messages.success(request, i)
form = PaperBoyForm()
uform = UserCreationForm()
return render(request, 'manager/create.html', {
'form': form,
'uform': uform,
'theme': 'Add'
})
def signup(request):
if request.user.is_authenticated:
messages.success(request,
"You can't access this page while logged in..")
return redirect('enduser:index')
if request.POST:
form = UserCreationForm(request.POST)
pform = UserProfileForm(request.POST)
if form.is_valid() and pform.is_valid():
user_obj = form.save()
user_prof = pform.save(commit=False)
user_prof.user = user_obj
user_pincode = request.POST.get('pincode')
paper_boy_obj = PaperBoy.objects.get_paper_boy(user_pincode)
user_prof.paper_boy = paper_boy_obj
user_prof.save()
messages.success(request, "Account Created successfully...Login")
return redirect('accounts:login')
else:
errors = form.errors.as_data()
for key in errors:
error_list = errors[key][0]
for i in error_list:
messages.success(request, i)
errors = pform.errors.as_data()
for key in errors:
error_list = errors[key][0]
for i in error_list:
messages.success(request, i)
form = UserCreationForm()
pform = UserProfileForm()
return render(request, 'enduser/signup.html', {
'form': form,
'pform': pform
})
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 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 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 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(request):
"""
Register API for non-web environment.(Especially for testing.)
"""
try:
body_data = json.loads(request.body)
except JSONDecodeError:
return JsonResponse({
'status': 'error',
'status_code': 'invalid_body',
'status_message': 'No json data exists.'
})
with transaction.atomic(
): # Queries will be committed if the below codes run without error.
reg_form = UserCreationForm(data=body_data) # register
if reg_form.is_valid(
): # if get succeed to register then login the user.
reg_form.save()
username = body_data['username']
password = body_data['password1']
user = authenticate(request=request,
username=username,
password=password)
auth_login(request, user)
try:
user.create_node()
except Exception as e:
logger.error('FAIL TO CREATE A USER NODE FOR {u}, {e}'.format(
u=username, e=e))
return JsonResponse({
'status': 'success',
'status_code': '',
'status_message': ''
})
logger.info(reg_form.errors)
return JsonResponse({
'status': 'error',
'status_code': 'invalid_data',
'status_message': 'Please check your input.'
})
def signup_view(request):
if request.user.is_authenticated:
return redirect('accounts_profile')
else:
if request.method == 'POST':
form = UserCreationForm(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('accounts_profile')
else:
form = UserCreationForm
return render(request, 'accounts/signup.html', {'form': form})
def register(request):
if request.method == 'GET':
form=UserCreationForm()
return render(request,'registration.html',{'form':form,'student_list' :MyUser.objects.exclude(pk=1)})
if request.method == 'POST':
form = UserCreationForm(request.POST, request.FILES or None)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('registrationsuccess'))
else:
return render(request,"registration.html",{'form':form})
else:
form =UserCreationForm()
return render(request, 'login.html', {
'form': form
})
def register_view(request, *args, **kwargs):
if request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = form.save()
login(request, user)
return redirect('list')
else:
form = UserCreationForm()
return render(request, 'accounts/user_create.html', context={'form': form})
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 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 SignUp(request):
error = ''
if request.method == "POST":
form = UserCreationForm(request.POST)
if form.is_valid():
try:
form.save()
user = form.save()
login(request, user)
url = '/'
return HttpResponseRedirect(url)
except IntegrityError:
error = u'Duplicate username'
else:
error = u'Invalid input'
else:
form = UserCreationForm()
return render(request, 'signup.html', {
'form': form,
'error': error,
})
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 register(request):
"""User Register GET / POST"""
logout(request) # To make a session out
if request.method == 'GET':
reg_form = UserCreationForm()
return render(request, 'accounts/register.html',
{'reg_form': reg_form})
"""
If the request method is POST, a form input will be requested.
If the input is validated, will create a user and will be redirected to feed.
else, return a view which is same with the GET which involved the error messages.
"""
with transaction.atomic(
): # Queries will be committed if the below codes run without error.
reg_form = UserCreationForm(data=request.POST) # register
if reg_form.is_valid(
): # if get succeed to register then login the user.
reg_form.save()
username = request.POST['username']
password = request.POST['password1']
user = authenticate(request=request,
username=username,
password=password)
auth_login(request, user)
try:
user.create_node()
except Exception as e:
logger.error('FAIL TO CREATE A USER NODE FOR {u}, {e}'.format(
u=username, e=e))
return redirect(settings.LOGIN_REDIRECT_URL)
# To get the first among multiple errors.
error_message = list(reg_form.errors.as_data().values())[0][0].message
# There are some validation errors in the form. the errors are saved in form.errors.
context = {'reg_form': reg_form, 'error_message': error_message}
return render(request, 'accounts/register.html', context)
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_view(request, *args, **kwargs):
if request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = form.save()
user.save()
user.set_password(form.cleaned_data['password'])
login(request, user)
return HttpResponseRedirect(
reverse('accounts:user_detail', kwargs={"pk": user.pk}))
else:
form = UserCreationForm()
return render(request, 'register.html', context={'form': form})
def registration(request):
if request.user.is_authenticated:
return redirect(reverse('index'))
if request.method == "POST":
registration_form = UserCreationForm(request.POST) # instance of form
if registration_form.is_valid():
registration_form.save()
user = auth.authenticate(username=request.POST['username'],
password=request.POST['password1'])
if user:
auth.login(user=user, request=request)
messages.success(request, "Congrats! You have successfully registered!")
return redirect(reverse('index'))
else:
messages.error(request, "We can't register your account at the moment")
else:
registration_form = UserCreationForm()
#request object
return render(request, 'registration.html', {"registration_form": registration_form}) # context dict key + (value - name of instance above)
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 create_branch(request):
if request.method == "POST":
form = BranchForm(request.POST)
mform = ManagerForm(request.POST)
uform = UserCreationForm(request.POST)
if form.is_valid() and mform.is_valid() and uform.is_valid():
user_obj = uform.save()
user_obj.user_type = "manager"
user_obj.save()
branch_obj = form.save()
manger_obj = mform.save(commit=False)
manger_obj.branch = branch_obj
manger_obj.user = user_obj
manger_obj.save()
messages.success(request, "Branch created successfully")
return redirect('newsadmin:index')
else:
errors = uform.errors.as_data()
for key in errors:
error_list = errors[key][0]
for i in error_list:
messages.success(request, i)
errors = mform.errors.as_data()
for key in errors:
error_list = errors[key][0]
for i in error_list:
messages.success(request, i)
errors = form.errors.as_data()
for key in errors:
error_list = errors[key][0]
for i in error_list:
messages.success(request, i)
form = BranchForm()
uform = UserCreationForm()
mform = ManagerForm()
return render(request, 'newsadmin/create_branch.html', {
'form': form,
'mform': mform,
'uform': uform,
'theme': 'Add'
})
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 post(self, request, *args, **kwargs):
user_form = UserCreationForm(request.POST, prefix="user")
company_form = CompanyCreationForm(request.POST, 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 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 register_view(request, *args, **kwargs):
if request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = form.save()
user.save()
try:
photo = request.FILES['photo']
except:
photo = None
profile = Profile(
user=user,
# role=form.cleaned_data['role'],
phone_number=form.cleaned_data['phone_number'],
photo=photo,
servicetype=form.cleaned_data['servicetype'],
car=form.cleaned_data['car'],
mark=form.cleaned_data['mark'],
city=form.cleaned_data['city'],
country=form.cleaned_data['country'],
role=form.cleaned_data['role'],
)
user.set_password(form.cleaned_data['password'])
# passport.save()
profile.save()
role = form.cleaned_data['role']
role = Role.objects.filter(pk=role.pk)
profile.save()
# profile.role.save(role)
login(request, user)
return HttpResponseRedirect(
reverse('accounts:user_detail', kwargs={"pk": user.pk}))
else:
form = UserCreationForm()
return render(request, 'user_create.html', context={'form': form})
