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 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 register_view(request):
if request.method == 'GET':
form = UserCreationForm()
return render(request, 'register.html', {'form': form})
elif request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = User(
username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
is_active=False # user не активный до подтверждения email
)
user.set_password(form.cleaned_data['password'])
user.save()
# токен для активации, его сложнее угадать, чем pk user-а.
token = Token.objects.create(user=user)
activation_url = HOST_NAME + reverse('accounts:user_activate') + \
'?token={}'.format(token)
# отправка письма на email пользователя
user.email_user(
'Регистрация на сайте localhost',
'Для активации перейдите по ссылке: {}'.format(activation_url))
print(activation_url)
return redirect("webapp:todo_index")
else:
return render(request, 'register.html', {'form': form})
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 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 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_view(request):
if request.method == 'GET':
form = UserCreationForm()
return render(request, 'register.html', {'form':form})
elif request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = User(username=form.cleaned_data['username'])
user = User(
username=form.cleaned_data['username'],
email=form.cleaned_data['email'],
is_active=False #user не активный до подтверждения email
)
user.set_password(form.cleaned_data['password'])
user.save()
Profile.objects.create(user=user)
#токен для активации, его сложнее угадать, чем pk user
token = Token.objects.create(user=user)
activation_url=HOST_NAME + reverse('accounts:user_activate') + \
'?token={}'.format(token)
#отправка письма на email пользователя
user.email_user('Registration on the site localhost',
'To activate, follow the link: {}'.format(activation_url))
return redirect('webapp:index')
else:
return render(request, '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_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(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 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 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 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 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 register_view(request):
if request.method == 'GET':
form = UserCreationForm()
return render(request, 'register.html', {'form': form})
elif request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = User(username=form.cleaned_data['username'],
email=form.cleaned_data['email'])
user.set_password(form.cleaned_data['password'])
user.save()
login(request, user)
return redirect("webapp:index")
else:
return render(request, 'register.html', {'form': form})
def test_valid_user_creation_form(self):
"""
the test is to test a form with a valid data
"""
user_creation_form = {'id':2, 'email':'*****@*****.**', 'password':'******', 'first_name':'first_name', 'last_name':'last_name'}
form = UserCreationForm(data=user_creation_form)
self.assertTrue(form.is_valid())
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 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()
class SignupView(View):
"""Class handling the registration form"""
ctx = {
"form": UserCreationForm(),
"form_title": "Créez votre compte",
"form_button": "S'inscrire",
"form_option_title": "Vous avez déjà un compte ?",
"form_option_target": reverse_lazy("login"),
"form_option_button": "Se connecter",
}
def get(self, request, *args, **kwargs):
"""Renders the registration form, or redirect to 'account' if the user
is already authenticated
"""
if request.user.is_authenticated:
return redirect("account")
return render(request, "auth_form.html", self.ctx)
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_view(request):
if request.method == 'POST':
form = UserCreationForm(data=request.POST)
if form.is_valid():
user = User(username=form.cleaned_data['username'],
first_name=form.cleaned_data['first_name'],
last_name=form.cleaned_data['last_name'],
email=form.cleaned_data['email'])
user.set_password(form.cleaned_data['password'])
user.save()
UserProfile.objects.create(user=user)
login(request, user)
return redirect('webapp:index')
else:
form = UserCreationForm()
return render(request, 'user_create.html', context={'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 book_detail(request, book_id):
book = get_object_or_404(Book, id=book_id)
likes = 0
top_rated_review = book.review_set.first()
for review in book.review_set.all():
if review.comment_set.count() > likes:
likes = review.comment_set.count()
top_rated_review = review
other_images = []
for bookImage in book.bookimage_set.all():
if bookImage.is_main == False:
other_images.append(bookImage)
context = {
'userLoginForm': UserLoginForm(),
'userCreationForm': UserCreationForm(),
'book': book,
'other_images': other_images,
'top_rated_review': top_rated_review,
'reviewForm': ReviewForm(),
'commentForm': CommentForm(),
}
return render(request, 'frontend/book_detail.html', context)
def test_invalid_user_registration_form(self):
form = UserCreationForm({
'email': '*****@*****.**',
'name': 'Test User',
'password1': 'hoonoruru',
})
self.assertFalse(form.is_valid())
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 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 post(self, request):
if not request.user.is_authenticated():
args = {}
args.update(csrf(request))
args['form'] = UserCreationForm()
new_user_form = UserCreationForm(request.POST)
if new_user_form.is_valid():
new_user = User.objects.create_user(
username=new_user_form.cleaned_data['username'].lower().
rstrip(),
first_name=new_user_form.cleaned_data['first_name'].rstrip(
),
last_name=new_user_form.cleaned_data['last_name'].rstrip(),
email=new_user_form.cleaned_data['email'].rstrip(),
)
new_user.set_password(new_user_form.cleaned_data["password2"]
) # хеширует пароль :С
new_user.is_active = False
new_user.save()
Group.objects.get(name='Customers').user_set.add(new_user)
SecretHashCode(user_id=new_user.pk,
hashcode=''.join(
random.choice(string.ascii_uppercase +
string.digits)
for _ in range(12)),
expired_date=datetime.now(timezone.utc) +
timedelta(minutes=60)).save()
# auth.login(request, new_user)
__new_hash = SecretHashCode.objects.get(
user_id=new_user.pk).hashcode
return send_email(
type='register',
email=new_user_form.cleaned_data['email'],
username=new_user_form.cleaned_data['username'].lower(),
password=new_user_form.cleaned_data['password2'],
first_name=new_user_form.cleaned_data['first_name'],
last_name=new_user_form.cleaned_data['last_name'],
hash_code=__new_hash)
else:
args['form'] = new_user_form
return render(request, 'accounts/register.html', args)
raise Http404()
def index(request):
context = {
'books': Book.objects.all(),
'booksImages': BookImage.objects.filter(is_main=True),
'userLoginForm': UserLoginForm(),
'userCreationForm': UserCreationForm()
}
return render(request, 'frontend/index.html', context)
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 test_arise_password_dont_match(self):
form = UserCreationForm({
'email': '*****@*****.**',
'name': 'Test User',
'password1': 'hoonoruru',
'password2': 'hoonodruru',
})
self.assertFalse(form.is_valid())
