def register(request):
activate(request.LANGUAGE_CODE)
if not isinstance(request.user, models.AnonymousUser):
logout(request)
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserExtendedForm(data=request.POST)
user_tz = request.POST.get('timezone')
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
profile = profile_form.save(commit=False)
profile.user = user
if user_tz:
profile.timezone = user_tz
try:
profile.save()
except:
raise ValidationError("Can't save user to the database!")
user.save()
return HttpResponseRedirect(reverse('users:login'))
else:
user_form = UserForm()
profile_form = UserExtendedForm()
return render(
request, 'users/register.html', {
'user_form': user_form,
'profile_form': profile_form,
'timezones': pytz.common_timezones,
'def_timezone': settings.DEF_USER['timezone']
})
def user_register(request):
form = UserForm()
if request.method == 'POST':
f = UserForm(request.POST)
#form.permissao = request.POST['permissao']
valido = False
if f.is_valid():
valido = True
u = f.save(commit=False)
u.date_joined = datetime.date.today()
# request.POST['permissao']
u.permissao = f.cleaned_data['permissao']
u.save()
c = {
'form': form,
}
if valido:
c['sucesso'] = True
else:
c['sucesso'] = False
return render(request, 'users/register.html', c)
# return redirect('user_login')
c = {
'form': form,
}
return render(request, 'users/register.html', c)
def register(request):
if request.method == 'GET':
form = UserForm()
greeting = 'Please register an account'
context = {
'form': form,
'greeting': greeting
}
return render(request, 'users/register.html', context)
else:
form = UserForm(request.POST)
if form.is_valid():
user = User(username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'])
user.set_password(form.cleaned_data['password'])
user.save()
profile = UserProfile(user=user)
profile.save()
return redirect('/login/')
else:
context = {
'form': form,
'greeting': 'Invalid fields, please check errors.'
}
return render(request, 'users/register.html', context)
def user_register(request):
if request.method == "GET":
user_form = UserForm()
profile_form = ProfileForm()
elif request.method == "POST":
user_form = UserForm(request.POST)
profile_form = ProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
profile = profile_form.save(commit=False)
profile.user = user
profile.save()
password = user.password
# The form doesn't know to call this special method on user.
user.set_password(password)
user.save()
# You must call authenticate before login. :(
user = authenticate(username=user.username, password=password)
login(request, user)
messages.add_message(
request, messages.SUCCESS,
"Congratulations, {}, on creating your new account! You are now logged in."
.format(user.username))
return redirect('index')
return render(request, "users/register.html", {
'user_form': user_form,
'profile_form': profile_form
})
def register(request):
""" Register a new user """
# Set registered to false by default
registered = False
if request.method != 'POST': # This SHOULD always be post
form = UserForm()
account_form = UserAccountForm()
else:
form = UserForm(data=request.POST)
account_form = UserAccountForm(data=request.POST)
if form.is_valid() and account_form.is_valid():
new_user = form.save()
new_user.set_password(new_user.password)
new_user.save()
account = account_form.save(commit=False)
account.user = new_user
account.save()
registered = True
login(request, new_user)
return redirect('book_keeping:index')
else:
print(form.errors, account_form.errors)
context = {
'form': form,
'account_form': account_form,
'registered': registered
}
return render(request, 'users/register.html', context)
def create_user(request):
if request.method== "POST":
form = UserForm(request.POST)
if form.is_valid():
password = get_random_string(length=7)
data = {
'user_name': form.data['user_name'],
'email' : form.data['email'],
'password': password
}
auth = User.objects.create_user(data)
user_profile = UsersProfile()
user_profile.email = form.data['email']
user_profile.user_type = form.data['user_type']
user_profile.user_name = form.data['user_name']
user_profile.user = auth
user_profile.save()
# send_mail(
# 'Customer creation',
# 'Please find the credentials.',
# 'from_email',
# [form.data['email']],
# html_message= 'username :% s' % form.data['user_name'],
# fail_silently=False,
# )
return redirect('/customer_list')
else:
form = UserForm()
return render(request, 'create_user.html', {'form': form})
def register(request):
res = create_exception(
request, __name__, exception="unknown request method")
if request.method == "POST":
form = UserForm(request.POST)
if form.is_valid():
user_obj = form.save()
user_obj.first_name = user_obj.first_name.capitalize()
user_obj.last_name = user_obj.last_name.capitalize()
username = user_obj.first_name.lower(
)[0] + user_obj.last_name.lower() + str(randint(1, 10000))
user_obj.username = username
user_details_obj = Personal_Info(username=username, date_of_birth=form.cleaned_data['date_of_birth'],
pin_code=form.cleaned_data['pin_code'], address=form.cleaned_data['address'],
city=form.cleaned_data['city'], email_verified=False)
try:
user_obj.save()
user_details_obj.save()
print("{} : {} {} added".format(
username, user_obj.first_name, user_obj.last_name))
except Exception as e:
print(e)
res = create_exception(request, __name__, exception=e)
else:
res = redirect('dashboard')
else:
res = create_exception(request, __name__, str(
ValueError("form data in request not valid")))
elif request.method == "GET":
empty_form = UserForm()
res = render(request, "users/register.html", {"form": empty_form, "helper": empty_form.get_helper()})
return res
def cadastro(request):
if request.method == 'POST':
form = UserForm(request.POST)
form_perfil = PerfilForm(request.POST)
print(form_perfil.is_valid())
if form.is_valid() and form_perfil.is_valid():
user = form.save()
perfil = form_perfil.save(commit=False)
perfil.user = user
perfil.save()
email = form.cleaned_data.get('username')
password = form.cleaned_data.get('password1')
user = authenticate(username=email, password=password)
auth_login(request, user)
return redirect('/')
else:
form = UserForm(request.POST)
form_perfil = PerfilForm(request.POST)
contexto = {
'form': form,
'form_perfil': form_perfil,
}
return render(request, 'cadastro.html', contexto)
def register(request):
form = UserForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
time = request.POST.get('time', '')
nama = request.POST.get('nama', '')
email = request.POST.get('email', '')
phone = request.POST.get('phone', '')
pekerjaan = request.POST.get('pekerjaan', '')
institusi = request.POST.get('institusi', '')
user_obj = User(time=time,
nama=nama,
email=email,
phone=phone,
pekerjaan=pekerjaan,
institusi=institusi)
user_obj.save()
email_subject = 'Registrasi KLAS'
email_body = "Hallo, %s, terimaksih telah mendaftar. Jangan lupa ikuti event Cangkru'an." % (
nama)
send_mail(email_subject, email_body, '*****@*****.**',
[email])
return render(request, 'users/register.html', {
'user_obj': user_obj,
'is_registered': True
})
else:
form = UserForm()
return render(request, 'users/register.html', {'form': form})
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
if user_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
registered = True
return render(request, 'login.html', {})
else:
print(user_form.errors)
else:
user_form = UserForm()
# Render the template depending on the context.
return render(request, 'register.html', {
'user_form': user_form,
'registered': registered
})
def register(request):
registed = False
if request.method == "POST":
user_form = UserForm(data=request.POST)
custom_form = CustomUserForm(data=request.POST)
if user_form.is_valid() and custom_form.is_valid():
user = user_form.save()
user.save()
custom = custom_form.save(commit=False)
custom.user = user
custom.save()
registed = True
return HttpResponseRedirect(reverse('login'))
else:
print(user_form.errors, custom_form.errors)
else:
user_form = UserForm()
custom_form = CustomUserForm
return render(request, 'users/register.html', {
'registed': registed,
'user_form': user_form,
'custom_form': custom_form
})
def register_customer(request):
registered = False
if request.method == "POST":
user_form = UserForm(data=request.POST)
customer_form = CustomerForm(data=request.POST)
if user_form.is_valid() and customer_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
customer = customer_form.save(commit=False)
customer.user = user
customer.save()
registered = True
else:
print(user_form.errors, customer_form.errors)
else:
user_form = UserForm()
customer_form = CustomerForm()
return render(
request, 'users/register_customer.html', {
'user_form': user_form,
'customer_form': customer_form,
'registered': registered
})
def register(request):
form = UserForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
time = request.POST.get('time', '')
nama = request.POST.get('nama', '')
email = request.POST.get('email', '')
phone = request.POST.get('phone', '')
pekerjaan = request.POST.get('pekerjaan', '')
institusi = request.POST.get('institusi', '')
user_obj = User(time=time,
nama=nama,
email=email,
phone=phone,
pekerjaan=pekerjaan,
institusi=institusi)
user_obj.save()
return render(request, 'users/register.html', {
'user_obj': user_obj,
'is_registered': True
})
else:
form = UserForm()
return render(request, 'users/register.html', {'form': form})
def register(request):
if request.method == 'POST':
form = UserForm(request.POST)
# print(form.errors.as_data())
if form.is_valid():
user = form.save(commit=False)
user.is_active = False
pwd = form.cleaned_data['password']
user.set_password(pwd)
user.save()
current_site = get_current_site(request)
mail_subject = 'Activate your account.'
message = render_to_string(
'users/activatemail.html', {
'user': user,
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user.id)),
'token': account_activation_token.make_token(user),
})
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'
)
else:
form = UserForm()
return render(request, 'users/registration.html', {'user_form': form})
def new_user(request):
"""Create a new user"""
if request.method == "POST":
form = UserForm(request.POST)
if form.is_valid():
data = form.cleaned_data
user = User.create(
name=data.get("username"),
password=data.get("password").encode("ascii", "ignore"),
email=data.get("email", ""),
administrator=data.get("administrator", False),
active=data.get("active", False),
username=request.user.name,
)
messages.add_message(
request,
messages.INFO,
"The user '{}' has been created".format(user.name),
)
return redirect("users:home")
else:
form = UserForm()
ctx = {
"form": form,
}
return render(request, "users/new.html", ctx)
def SignUp(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data=request.POST)
profile_form = UserProfileInfoForm(data=request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'profile_pic' in request.FILES:
profile.profile_pic = request.FILES['profile_pic']
profile.save()
registered=True
else:
print(user_form.errors, profile_form.errors)
else:
user_form = UserForm()
profile_form = UserProfileInfoForm()
return render(request, 'signup.html',{'user_form':user_form,'profile_form':profile_form, 'registered':registered})
def register(request):
registered = False
if request.method == 'POST':
user_form = UserForm(data = request.POST)
profile_form = UserProfileInfoForm(data= request.POST)
if user_form.is_valid() and profile_form.is_valid() :
user = user_form.save()
user.save()
profile = profile_form.save(commit= False)
profile.user = user
profile.save()
registered = True
else:
print(user_form.errors,profile_form.errors)
else:
user_form =UserForm()
profile_form = UserProfileInfoForm()
context ={
'registered': registered,
'user_form': user_form,
'profile_form': profile_form,
}
return render(request, 'users/registration.html', context)
def accept_invite(request, token):
invite = get_object_or_404(Invite, token=token)
if not invite.is_tokened:
invite.is_tokened = True
invite.save()
user = User.objects.filter(email=invite.email)
if user.exists():
_create_event_member(user[0], invite.event)
login(request, user[0])
return redirect('post_details', invite.event.id)
else:
form = UserForm()
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
password = form.cleaned_data['password']
email = form.cleaned_data['email']
member = form.save()
_create_event_member(member, invite.event)
user = authenticate(email=email, password=password)
if user is not None:
login(request, user)
return redirect('post_details', invite.event.id)
return render(request, 'users/signup.html', {'form': form})
else:
raise Http404("Token does not exist")
def Register(request):
context = RequestContext(request)
registered = False
if request.method == 'POST':
user_form = UserForm(request.POST)
profile_form = UserProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
profile = profile_form.save(commit=False)
profile.user = user
if 'picture' in request.FILES:
profile.picture = request.FILES['picture']
profile.save()
registered = True
login(request, user)
return redirect('home')
else:
print user_form.errors, profile_form.errors
else:
user_form = UserForm()
profile_form = UserProfileForm()
return render(request,
'users/register.html',
{'user_form': user_form, 'profile_form': profile_form, 'registered': registered})
def settings(request):
usr = request.user
form = UserForm(instance=usr)
try:
pno = usr.contactdetails
# print(pno, usr.contactdetails)
pform = UpdatePhoneNo(instance=pno)
except:
pno = None
pform = UpdatePhoneNo()
if request.method == 'POST':
pform = UpdatePhoneNo(data=request.POST, instance=pno)
form = UserForm(data=request.POST, instance=usr)
if pform.is_valid():
p_obj = pform.save(commit=False)
p_obj.user = request.user
p_obj.save()
if form.is_valid():
form.save()
return render(request, 'users/settings.html', locals())
else:
return render(request, 'users/settings.html', locals())
def post(self,request):
user = User()
form = UserForm(data=request.POST)
form.instance = user
if form.is_valid():
user.first_name = form.cleaned_data.get('first_name')
user.last_name = form.cleaned_data.get('last_name')
user.email = form.cleaned_data.get('email')
user.username = form.cleaned_data.get('username')
password = form.cleaned_data.get('password')
user.set_password(password)
user.save()
blog = Blog(user=user)
blog.name = form.cleaned_data.get('blog_name')
blog.description = form.cleaned_data.get('blog_description')
blog.save()
# logeamos al usaurio
authenticate_user = authenticate(username=user.username, password=password)
django_login(request, authenticate_user)
# vaciamos el formulario
form = UserForm()
url = reverse("create_post")
message = "User with blog created successfully!"
message += '<a href="{0}">Create you first post</a>'.format(url)
# enviamos mensaje de exito con un enlace al blog que acabamos de crear
messages.success(request, message)
return render(request, "singup_form.html", {'form': form})
def update_profile(request):
if request.method == 'POST':
user_form = UserForm(request.POST)
profile_form = ProfileForm(request.POST)
if user_form.is_valid() and profile_form.is_valid():
u = user_form.save()
u.set_password(request.POST['password'])
u.save()
Profile.objects.get_or_create(
user=u,
position=request.POST.get('position'),
phone=request.POST.get('phone'),
address=request.POST.get('address'),
birth_date=request.POST.get('birth_date'),
joined_date=request.POST.get('joined_date'),
image=request.FILES.get('image'))
# profile_form.save()
messages.success(request,
('Your profile was successfully updated!'))
return redirect('core:main_dashboard')
else:
messages.error(request, ('Please correct the error below.'))
else:
user_form = UserForm()
profile_form = ProfileForm()
# user_form = UserForm(instance=request.user)
# profile_form = ProfileForm(instance=request.user.profile)
return render(request, 'core/register_new_member.html', {
'user_form': user_form,
'profile_form': profile_form
})
def register(request):
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
form.save()
else:
form = UserForm()
return render(request, 'users/register.html', context={'form': form})
def test_codename_visibility(self):
# Show for staff
self.assertIn('codename',
UserForm(instance=UserFactory(is_staff=True)).fields)
# Non-show for non-staff
self.assertNotIn('codename',
UserForm(instance=UserFactory(is_staff=False)).fields)
# Non show for new object
self.assertNotIn('codename', UserForm().fields)
def create_user(request):
if request.method == 'POST':
form = UserForm(request.POST)
profile = ProfileForm(request.POST)
if form.is_valid() and profile.is_valid():
shops = profile.cleaned_data['shops']
#save form
user_data = form.save(commit=False)
user_data.save()
#save profile form
profile_data = profile.save(commit=False)
profile_data.creator = request.user
profile_data.updater = request.user
profile_data.user = user_data
profile_data.current_shop = shops[0]
profile_data.save()
profile.save_m2m()
request.session['message'] = 'User Created Successfully'
return HttpResponseRedirect(
reverse('users:view_user', kwargs={'pk': profile_data.pk}))
else:
errors = generate_form_errors(form, formset=False)
errors += generate_form_errors(profile, formset=False)
context = {
'form': form,
'profile': profile,
'title': 'Create User',
'message': 'Form Validation Error',
"errors": errors,
'url': reverse('users:create_user'),
"users_active": "active"
}
return render(request, 'users/entry_user.html', context)
else:
form = UserForm()
profile = ProfileForm()
context = {
"form": form,
"profile": profile,
"title": "Create User",
'url': reverse('users:create_user'),
"users_active": "active"
}
return render(request, 'users/entry_user.html', context)
def submit(request):
if request.method == "POST":
form = UserForm(request.POST)
if form.is_valid():
print("***")
user = form.save()
#return JsonResponse({"msg": "Пользователь добавлен", "id": user.id}, status=201)
return HttpResponseRedirect('/all_right/')
else:
form = UserForm()
return render(request, 'users/submit.html', {'form': form})
def post(self, request):
form = UserForm(request.POST)
if form.is_valid():
new_user = User.objects.create_user(**form.cleaned_data)
return redirect('/users/login/?error={}'.format(
"signup a success! now please login"))
else:
return render(
request, 'users/create.html', {
'error': "Not a valid name or password",
'form': UserForm(request.POST)
})
def test_user_form(self):
"""Test the combined User and BucketUser form"""
form = UserForm(instance=self.user)
self.assertEqual(type(form.bucket_user_form), BucketUserForm)
data = {'first_name': 'Foo', 'last_name': 'Bar', 'bio': 'about me'}
form = UserForm(data=data, instance=self.user)
self.assertTrue(form.is_valid())
form.save()
self.assertEqual(self.user.first_name, 'Foo')
self.assertEqual(self.user.last_name, 'Bar')
bucket_user = BucketUser.objects.get(user=self.user)
self.assertEqual(bucket_user.bio, 'about me')
def signup(request):
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
user = form.save()
login(request,
user,
backend="django.contrib.auth.backends.ModelBackend")
return redirect('/')
else:
form = UserForm()
return render(request, 'registration/signup.html', {'form': form})
def register(request):
# A boolean value for telling the template whether the registration was successful.
# Set to False initially. Code changes value to True when registration succeeds.
registered = False
# If it's a HTTP POST, we're interested in processing form data.
if request.method == 'POST':
# Attempt to grab information from the raw form information.
# Note that we make use of both UserForm and UserProfileForm.
user_form = UserForm(data=request.POST)
profile_form = UserProfileForm(data=request.POST)
# If the two forms are valid...
if user_form.is_valid() and profile_form.is_valid():
# Save the user's form data to the database.
user = user_form.save()
# Now we hash the password with the set_password method.
# Once hashed, we can update the user object.
user.set_password(user.password)
user.save()
# Now sort out the UserProfile instance.
# Since we need to set the user attribute ourselves, we set commit=False.
# This delays saving the model until we're ready to avoid integrity problems.
profile = profile_form.save(commit=False)
profile.user = user
# Now we save the UserProfile model instance.
profile.save()
# Update our variable to tell the template registration was successful.
registered = True
# Invalid form or forms - mistakes or something else?
# Print problems to the terminal.
# They'll also be shown to the user.
else:
print(user_form.errors, profile_form.errors)
# Not a HTTP POST, so we render our form using two ModelForm instances.
# These forms will be blank, ready for user input.
else:
user_form = UserForm()
profile_form = UserProfileForm()
# Render the template depending on the context.
return render(
request, 'register.html', {
'user_form': user_form,
'profile_form': profile_form,
'registered': registered
})
