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 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 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 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_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 test_user_without(self): """ Without data """ form_data = {} form = UserCreationForm(data=form_data) self.assertEqual(form.is_valid(), False)
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 test_user_email(self): """ Wrong email """ form_data = {'user_type':0, 'email':'toemail', 'password': '******'} form = UserCreationForm(data=form_data) self.assertEqual(form.is_valid(), False)
def register(request, success_url='registration_complete', template_name='accounts/registration_form.html', extra_context=None): """ Allow a new user to register an account. """ if request.method == 'POST': form = UserCreationForm(data=request.POST, files=request.FILES) if form.is_valid(): cleaned_data = form.cleaned_data new_user = User.objects.create_inactive_user(cleaned_data['email'], cleaned_data['password1']) signals.user_registered.send(sender=User, user=new_user, request=request) return redirect(success_url) else: form = UserCreationForm() if extra_context is None: extra_context = {} context = RequestContext(request) for key, value in extra_context.items(): context[key] = callable(value) and value() or value return render_to_response(template_name, {'form': form}, context_instance=context)
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 test_invalid_user_registration_form(self): form = UserCreationForm({ 'email': '*****@*****.**', 'name': 'Test User', 'password1': 'hoonoruru', }) self.assertFalse(form.is_valid())
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_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_arise_password_dont_match(self): form = UserCreationForm({ 'email': '*****@*****.**', 'name': 'Test User', 'password1': 'hoonoruru', 'password2': 'hoonodruru', }) self.assertFalse(form.is_valid())
def test_invalid_user_creation_form_email(self): """ the method test the invalid form data here testing the unique email address , we give our user an existing email address and the email address must be unique """ user_creation_form = {'id':2, 'email':self.user.email, 'password':'******', 'first_name':'first_name', 'last_name':'last_name'} form = UserCreationForm(data=user_creation_form) self.assertFalse(form.is_valid()) self.assertIn('User with this Email already exists.', form.errors['email'])
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 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 test_user_creation_missing_data(self): """This test checks if the form can detect incomplete data""" form = UserCreationForm( data={ "first_name": "test", "last_name": "user", "password1": "test123", "password2": "test123", } ) self.assertFalse(form.is_valid())
def test_invalid_user_creation_form_password(self): """ the method test the invalid form data here testing the password the password must be numbers and alphapet and not less than 8 charchter """ user_creation_form = {'id':2, 'email':'*****@*****.**', 'password':'******', 'first_name':'first_name', 'last_name':'last_name'} form = UserCreationForm(data=user_creation_form) self.assertFalse(form.is_valid()) self.assertIn('This password is too short. It must contain at least 8 characters.', form.errors['password']) self.assertIn('This password is too common.', form.errors['password']) self.assertIn('This password is entirely numeric.', form.errors['password'])
def test_form(self): form_input = { 'username': '******', 'email': '*****@*****.**', 'password1': 'mypassword123', 'password2': 'mypassword123', } form = UserCreationForm(data=form_input) self.assertTrue(form.is_valid())
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 test_user_creation_valid_data(self): """This test checks if the form can be validated""" form = UserCreationForm( data={ "first_name": "test", "last_name": "user", "email": "*****@*****.**", "password1": "test123", "password2": "test123", } ) self.assertTrue(form.is_valid())
def test_user_creation_invalid_passwords(self): """This test checks if the form can detect non-matching passwords""" form = UserCreationForm( data={ "first_name": "test", "last_name": "user", "email": "*****@*****.**", "password1": "test123", "password2": "testabc", } ) self.assertFalse(form.is_valid())
def test_user_create_form_valid(): form = UserCreationForm( data={ 'email': '*****@*****.**', 'email1': '*****@*****.**', 'first_name': 'test', 'last_name': 'user', 'date_of_birth': '08/27/1975', 'password1': '@Password', 'password2': "@Password", }) assert form.is_valid()
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 test_creation_form_valid(self): ''' User can create unique and valid form :return: ''' data = { 'username': '******', 'email': '*****@*****.**', 'phone_number': '01049392222', 'password1': '!adkdkd33', 'password2': '!adkdkd33'} form = UserCreationForm(data=data) self.assertTrue(form.is_valid())
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 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(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_user_creation_form_invalid(): form = UserCreationForm( data={ 'email': '*****@*****.**', 'email1': '*****@*****.**', 'first_name': 'test', 'last_name': 'user', 'date_of_birth': '08/27/1975', 'password1': '@Password', 'password2': '@Password' }) assert form.is_valid() is False assert 'email1' in form.errors
def validate_performers(self): """ Проверка валидности данных через django формы """ for performer in self.performers: form = UserCreationForm(performer) form_profile = BaseProfileForm(performer) form_profile_phone = ProfilePhoneForm(performer) if not form.is_valid(): raise FormValidationError(form, performer) if not form_profile.is_valid(): raise FormValidationError(form, performer) if not form_profile_phone.is_valid(): raise FormValidationError(form, performer)
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, })
def test_creation_form_invalid(self): ''' User Can't Create duplicate User :return: ''' obj = MyUser.objects.get(email='*****@*****.**') data = { 'username': obj.username, 'email': obj.email, 'phone_number': obj.phone_number, 'password1': obj.password, 'password2': obj.password} form = UserCreationForm(data=data) self.assertFalse(form.is_valid())
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_registration_form_sends_email(self): form = UserCreationForm({ 'email': '*****@*****.**', 'name': 'Test User', 'password1': 'hoonoruru', 'password2': 'hoonoruru', }) self.assertTrue(form.is_valid()) with self.assertLogs('accounts', level='INFO') as cm: form.send_email() self.assertEqual(len(mail.outbox), 1) self.assertEqual(len(cm.output), 1)
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 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 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 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 new(request): context = {} user_form = UserCreationForm() user_profile_form = UserProfileForm() if request.method == "POST": user_profile_form = UserProfileForm(data=request.POST) if not user_profile_form.is_valid(): context['new_user_form'] = user_form context['new_user_profile_form'] = user_profile_form return render_to_response("new.html", RequestContext(request, context)) user_form = UserCreationForm(data=request.POST) if user_form.is_valid(): user = User.objects.create_user(user_form.cleaned_data['username'], user_form.cleaned_data['email'], user_form.cleaned_data['password']) if user_profile_form.is_valid(): user_profile = user_profile_form.save(commit=False) user_profile.user = user user_profile.save() try: team = Team.objects.get(name=request.POST['team']) except: team = Team(name=request.POST['team']) team.save() team_user = TeamUser(team=team, user=user) team_user.save() if request.POST.get("isadmin", False): user.groups.add(Group.objects.get(name="Administrator")) else: user.groups.add(Group.objects.get(name="Standard User")) return HttpResponseRedirect(reverse('accounts.views.login')) else: raise Exception("Form not valid") else: print user_form.errors pass context['new_user_form'] = user_form context['new_user_profile_form'] = user_profile_form return render_to_response("new.html", RequestContext(request, context))
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 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 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 test_form_user(self): form_data = {"email": "*****@*****.**", "password1": "zosia12", "password2": "zosia12"} form = UserCreationForm(data=form_data) self.assertEqual(form.is_valid(), True)