def checkout_success(request, order_number): save_info = request.session.get('save_info') order = get_object_or_404(Order, order_number=order_number) if request.user.is_authenticated: profile = UserProfile.objects.get(user=request.user) # connect profile to the order order.user = profile order.save() # Save the user's info if save_info: profile_data = { 'default_phone_number': order.phone_number, 'default_country': order.country, 'default_postcode': order.postcode, 'default_town_or_city': order.town_or_city, 'default_street_address1': order.street_address1, 'default_street_address2': order.street_address2, 'default_county': order.county, } user_form = UserForm(profile_data, instance=profile) if user_form.is_valid(): user_form.save() if 'cart' in request.session: del request.session['cart'] template = 'checkout/checkout_success.html' context = { 'order': order, } return render(request, template, context)
def edit_user(request): user = request.user rater = user.rater profile = user.profile if request.method == "POST": if "user_edit" in request.POST: user_form = UserForm(request.POST) if user_form.is_valid(): user_form.save(commit=False) password = user_form.password user.set_password(password) user.save() messages.add_message(request, messages.SUCCESS, "You have updated your account") elif "rater_edit" in request.POST: rater_form = RaterForm(request.POST) if rater_form.is_valid(): rater_form.save() messages.add_message(request, messages.SUCCESS, "You have updated your demographic info") elif "profile_edit" in request.POST: profile_form = ProfileForm(request.POST) if profile_form.is_valid(): profile_form.save() messages.add_message(request, messages.SUCCESS, "You have updated your profile") user_form = UserForm(request.POST or None, instance=request.user) rater_form = RaterForm(request.POST or None, instance=request.user.rater) profile_form = ProfileForm(request.POST or None, instance=request.user.profile) return render(request, "user_edit.html", {'user_form': user_form, 'rater_form': rater_form, 'profile_form':profile_form})
def user_update(request): """ User profile settings form """ user = request.user profile = request.user.get_profile() if request.method == "POST": user_form = UserForm(request.POST, instance=user, prefix="UserForm") profile_form = UserProfileForm(request.POST, request.FILES, instance=profile, prefix="UserProfileForm") if user_form.is_valid() and profile_form.is_valid(): user_form.save() profile_form.save() request.user.message_set.create(message=_("Your profile settings have been updated.")) return HttpResponseRedirect(profile.get_absolute_url()) else: user_form = UserForm(instance=user, prefix="UserForm") profile_form = UserProfileForm(instance=profile, prefix="UserProfileForm") return render_to_response("profiles/user_update.html", { "user_form" : user_form, "profile_form" : profile_form }, context_instance=RequestContext(request))
def view_dashboard(request): user = request.user rater = user.rater if request.method == "GET": pass elif request.method == "POST": if "user_edit" in request.POST: user_form = UserForm(request.POST) if user_form.is_valid(): user.username = requet.POST.get('username') user.email = requet.POST.get('email') user.save() messages.add_message(request, messages.SUCCESS, "You have updated your account") elif "rater_edit" in request.POST: rater_form = RaterForm(request.POST) if rater_form.is_valid(): rater.age = request.POST.get('age') rater.gender = request.POST.get('gender') rater.occupation = request.POST.get('occupation') rater.zip_code = request.POST.get('zip_code') rater.save() messages.add_message(request, messages.SUCCESS, "You have updated your profile") elif "delete_button" in request.POST: idx = int(request.POST.get('rating')) rating = Rating.objects.get(pk=idx) sometext = "Sucessfully deleted rating of {}".format(rating.movie.title) Rating.objects.get(pk=idx).delete() messages.add_message(request, messages.SUCCESS, sometext) user_form = UserForm(initial={'username':user.username, 'email':user.email}) rater_form = RaterForm(initial = {'age':rater.age, 'gender':rater.gender, 'occupation':rater.occupation, 'zip_code':rater.zip_code}) return render(request, "movies/dashboard.html", {'user_form': user_form, 'rater_form': rater_form})
def test_update_account_form(self): login = self.client.login(username="******", password="******") user = self.test_user response = self.client.post(reverse("update_account_details")) form_data = {"username": "******"} form = UserForm(data=form_data) self.assertTrue(form.is_valid())
def test_email_validation_raises_error_on_update(self, admin_user): """ Test taht error will be raised if passed email belong to another user. """ form = UserForm(instance=admin_user) user = User.objects.create_user('somesome', '*****@*****.**') form.cleaned_data = {'email': user.email} with pytest.raises(ValidationError): form.clean_email()
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 # Did the user provide a profile picture? # If so, we need to get it from the input form and put it in the UserProfile model. if 'picture' in request.FILES: profile.picture = request.FILES['picture'] # 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} )
def user_create(request): form = UserForm() if request.method == "POST": form = UserForm(request.POST) if form.is_valid(): form.save() user = authenticate(username=request.POST['username'], password=request.POST['password']) login(request,user) return HttpResponseRedirect(user.get_absolute_url()) return render_to_response("profiles/user_create.html",{"form":form},context_instance=RequestContext(request))
def create_user(request): if request.POST: formf = UserForm(request.POST) formf.save() return HttpResponseRedirect('/') else: form = UserForm() args = {} args.update(csrf(request)) args['form'] = form return render_to_response('create_user.html', args)
def checkout_success(request, order_number): """ This view displays details of a users order. The view also updates the user profile if the save-info box has been ticked. The session basket is also cleared. The "checkout success" boolean is used to identify the order progress. """ save_info = request.session.get('save_info') order = get_object_or_404(Order, order_number=order_number) if request.user.is_authenticated: profile = UserProfile.objects.get(user=request.user) order.user_profile = profile order.save() if save_info: delivery_data = { 'default_phone_number': order.phone_number, 'default_address_1': order.address_1, 'default_address_2': order.address_2, 'default_city': order.city, 'default_county': order.county, 'default_country': order.country, 'default_postcode': order.postcode, } user_data = { 'first_name': order.full_name.split()[0], 'last_name': order.full_name.split()[-1], 'email': order.email, } user_profile_form = UserProfileForm(delivery_data, instance=profile) if user_profile_form.is_valid(): user_profile_form.save() user_form = UserForm(user_data, instance=request.user) if user_form.is_valid(): user_form.save() if 'basket' in request.session: del request.session['basket'] context = { 'order': order, 'checkout_success': True, } return render(request, 'checkout/checkout_success.html', context)
def profile_edit(request): """ Edit profile page """ if request.method == "POST": user_form = UserForm(request.POST, instance=request.user) if user_form.is_valid(): user_form.save() return HttpResponseRedirect(reverse("profiles_profile_landing")) else: user_form = UserForm(instance=request.user) return render_to_response( "profiles/profile_form.html", {"user_form": user_form}, context_instance=RequestContext(request) )
def register(request): ''' TO DO: Authenticate email ''' if request.method == 'POST': formUser = UserForm(data=request.POST) formProfile=ProfileForm(data=request.POST) if formUser.is_valid() and formProfile.is_valid(): password1=formUser.cleaned_data['password'] password2=request.POST.get('password2') first_name=formUser.cleaned_data['first_name'] last_name=formUser.cleaned_data['last_name'] email=formUser.cleaned_data['email'] if(password1!=password2): return render(request, 'register.html', {'formUser': formUser, 'formProfile':formProfile,'passwordError':'passwordError'}) if User.objects.filter(username = email).exists(): return render(request, 'register.html', {'formUser': formUser, 'formProfile':formProfile, 'error_message':'error_message'}) user = formUser.save() user.set_password(user.password) user.is_active = False user.first_name=first_name user.last_name=last_name user.email=email user.username=email body=formProfile.cleaned_data['body'] birthDate=formProfile.cleaned_data['birthDate'] gender=formProfile.cleaned_data['gender'] city=formProfile.cleaned_data['city'] country=formProfile.cleaned_data['country'] address=formProfile.cleaned_data['address'] postalCode=formProfile.cleaned_data['postalCode'] phoneNumber=formProfile.cleaned_data['phoneNumber'] try: image = request.FILES['image'] except: image="" user.save() newProfile=Profile(user=user,body=body,birthDate=birthDate,gender=gender,city=city,address=address,postalCode=postalCode,phoneNumber=phoneNumber,country=country,image=image) newProfile.save() return HttpResponseRedirect('/profiles/login') else: formUser = UserForm() formProfile=ProfileForm() return render(request, 'register.html', {'formUser': formUser, 'formProfile':formProfile})
def add_info(request): # функция, выводящая форму для ввода информации о пользователе # или перенаправляющая на страницу профиля при повторной авторизации пользователя if request.method == 'POST': profile_form = UserProfileForm(request.POST, request.FILES, instance=request.user.profile) user_form = UserForm(request.POST, request.FILES, instance=request.user) if profile_form.is_valid() and user_form.is_valid(): profile_form.save() user_form.save() if info_is_completed(request.user): messages.success(request, 'Успешное изменение профиля!') return redirect('/my_profile/') else: messages.error(request, 'Необходимо ввести все поля формы') else: messages.error( request, 'Необходимо ввести корректные значения в поля формы!') elif info_is_completed(request.user): return redirect('/my_profile/') else: profile_form = UserProfileForm(instance=request.user.profile) user_form = UserForm(instance=request.user) heading = "Пожалуйста, введите все свои данные в форму ниже:" return render(request, 'data_input.html', { 'profile_form': profile_form, 'user_form': user_form, 'heading': heading })
def edit_profile(request): # метод для изменения информации о пользователе # используются две формы, которые отправляются на сервер одной кнопкой if request.method == 'POST': profile_form = UserProfileForm(request.POST, request.FILES, instance=request.user.profile) user_form = UserForm(request.POST, request.FILES, instance=request.user) if profile_form.is_valid() and user_form.is_valid(): profile_form.save() user_form.save() if info_is_completed(request.user): messages.success(request, 'Успешное изменение профиля!') return redirect('/my_profile/') else: messages.error(request, 'Необходимо ввести все поля формы') else: messages.error( request, 'Необходимо ввести корректные значения в поля формы!') else: profile_form = UserProfileForm(instance=request.user.profile) user_form = UserForm(instance=request.user) heading = "Здесь Вы можете изменить личную информацию профиля:" return render(request, 'data_input.html', { 'profile_form': profile_form, 'user_form': user_form, 'heading': heading })
def checkout_success(request, order_number): """ Handle successful checkouts """ order = get_object_or_404(Order, order_number=order_number) order_id = order.id line_items = OrderLineItem.objects.filter(order=order_id) save_info = request.session.get('save_info') if request.user.is_authenticated: profile = UserProfile.objects.get(user=request.user) order.user_profile = profile profile.loyalty_points += order.loyalty_points profile.save() order.save() if save_info: profile_data = { 'default_phone_number': order.phone_number, 'default_postcode': order.postcode, 'default_town_or_city': order.town_or_city, 'default_street_address1': order.street_address1, 'default_street_address2': order.street_address2, 'default_county': order.county, } user_profile_form = UserForm(profile_data, instance=profile) if user_profile_form.is_valid(): user_profile_form.save() if 'bag' in request.session: del request.session['bag'] if 'discount' in request.session: del request.session['discount'] if 'loyalty' in request.session: del request.session['loyalty'] template = 'checkout/checkout_success.html' context = { 'order': order, 'line_items': line_items, } return render(request, template, context)
def payment_success(request, order_number): """ Successful payments """ save_info = request.session.get('save_info') order = get_object_or_404(Payment, order_number=order_number) if request.user.is_authenticated: profile = UserProfile.objects.get(user=request.user) # Attach the user's profile to the order order.user_profile = profile order.save() # Save the user's info if save_info: profile_data = { 'email': order.email, 'phone_number': order.phone_number, 'country': order.country, 'street_address1': order.street_address1, 'street_address2': order.street_address2, 'town_or_city': order.town_or_city, 'county': order.county, 'postcode': order.postcode, } user_form = UserForm(profile_data, instance=profile) if user_form.is_valid(): user_form.save() messages.success(request, f'Booking successfully processed! \ Your order number is {order_number}. A confirmation \ email will be sent to {order.email} and your Expert will be in touch shortly by phone or email to book in a time and date.') if 'bag' in request.session: del request.session['bag'] template = 'payments/payment_success.html' context = { 'order': order, } return render(request, template, context)
def checkout_completed(request, order_number): """ Handles a completed checkout, and attaches it to a user profile """ save_info = request.session.get('save_info') order = get_object_or_404(Order, order_number=order_number) if request.user.is_authenticated: profile = UserProfile.objects.get(user=request.user) order.user_profile = profile order.save() # handles the save user info tick-box if save_info: profile_data = { 'default_phone_number': order.phone_number, 'default_country': order.country, 'default_postcode': order.postcode, 'default_town_or_city': order.town_or_city, 'default_street_address1': order.street_address1, 'default_street_address2': order.street_address2, 'default_county': order.county, 'default_country': order.country, } user_profile_form = UserForm(profile_data, instance=profile) if user_profile_form.is_valid(): user_profile_form.save() messages.success( request, f'Order successfully processed! \ Your order number is {order_number}. A confirmation \ email will be sent to {order.email}.') if 'basket' in request.session: del request.session['basket'] template = 'checkout/checkout_completed.html' context = { 'order': order, } return render(request, template, 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(commit=False) # setting password done in forms.py user.alias = user.username user.save() # extra password thing # 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. :( # end extra password thing profile = profile_form.save(commit=False) if Location.objects.count() > 0: profile.location = Location.objects.all()[0] profile.user = user profile.save() user = authenticate(username=request.POST['username'], password=request.POST['password']) login(request, user) messages.add_message( request, messages.SUCCESS, "Congratulations, {}, on creating your new account! You are now logged in.".format( user.username)) send_mail("Welcome to Share Lockers","""\ {}, Your account on sharelockers.come has been created! \ We look forward to seeing what you have to share. \ You might start by stocking some items to sell, or by adding items you have \ at home which you would be willing to sell. -ShareLockers Team""".format(user.username), settings.EMAIL_HOST_USER, [user.email], fail_silently=settings.EMAIL_SILENT) return redirect('view_index') return render(request, "profiles/register.html", {'user_form': user_form, 'profile_form': profile_form, })
def register(request, key=''): registered = False try: invite_record = Invitation.objects.get(key=key) if invite_record.activated == True: return HttpResponseRedirect(reverse('home')) except ObjectDoesNotExist: return HttpResponseRedirect(reverse('home')) if request.method == 'POST': user_form = UserForm(data=request.POST) profile_form = UserProfileForm(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) invite_record = Invitation.objects.get(key=key) profile.user = user if 'picture' in request.FILES: profile.picture = request.FILES['picture'] profile.save() registered = True invite_record.activated = True else: print user_form.errors, profile_form.errors else: user_form = UserForm(instance=invite_record) profile_form = UserProfileForm() return render(request, 'register.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered})
def register_user(request): context_dict = {} registered = False if request.method == 'POST': # user_form = UserForm(data=request.POST) user_form = UserForm(request.POST) if user_form.is_valid(): user = user_form.save(commit=True) person = Person() person.username = user.username person.email = user.email person.save() user.set_password(user.password) user.save() registered = True context_dict = {'boldmessage': "User createlly correctly"} else: print user_form.errors else: user_form = UserForm() return render(request, 'webUser/register.html', { 'user_form': user_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.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, 'profiles/register.html', { 'user_form': user_form, 'profile_form': profile_form, 'registered': registered })
def checkout_success(request, order_number): # Handle successful checkouts save_info = request.session.get('save-info') order = get_object_or_404(Order, order_number=order_number) if request.user.is_authenticated: profile = UserProfile.objects.get(user=request.user) order.user_profile = profile order.save() if save_info: profile_data = { 'default_full_name': order.full_name, 'default_email': order.email, 'default_phone_number': order.phone_number, 'default_street_address1': order.street_address1, 'default_street_address2': order.street_address1, 'default_town_or_city': order.town_or_city, 'default_county': order.county, 'default_postcode': order.postcode, 'default_country': order.country, } user_profile_form = UserForm(profile_data, instance=profile) if user_profile_form.is_valid(): user_profile_form.save() messages.success(request, f'Your order has been processes! \ Your order number is {order_number} and \ a confirmation has been sent to {order.email}.') if 'cart' in request.session: del request.session['cart'] template = 'checkout/checkout_success.html' context = { 'order': order, } return render(request, template, context)
def view_register(request): if request.method == "GET": user_form = UserForm() profile_form = ProfileForm() rater_form = RaterForm() elif request.method == "POST": user_form = UserForm(request.POST) rater_form = RaterForm(request.POST) profile_form = ProfileForm(request.POST) if user_form.is_valid() and rater_form.is_valid(): user = user_form.save() rater = rater_form.save(commit=False) rater.user = user profile = profile_form.save(commit=False) profile.user = user profile.age = rater.age profile.gender = rater.gender profile.save() rater.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('/') return render(request, "profiles/register.html", {'user_form': user_form, 'rater_form': rater_form})
def profile_edit(request, template_name='profiles/profile_form.html'): """Edit profile.""" if request.POST: profile = Profile.objects.get(user=request.user) user_form = UserForm(request.POST, instance=request.user) profile_form = ProfileForm(request.POST, request.FILES, instance=profile) service_formset = ServiceFormSet(request.POST, instance=profile) link_formset = LinkFormSet(request.POST, instance=profile) if profile_form.is_valid() and user_form.is_valid( ) and service_formset.is_valid() and link_formset.is_valid(): profile_form.save() user_form.save() link_formset.save() service_formset.save() # return HttpResponseRedirect(reverse('profile_detail', kwargs={'username': request.user.username})) return HttpResponseRedirect(reverse('profiles-profile-edit')) else: from lib.util.form_errors import merge_form_errors form_errors = merge_form_errors([ user_form, profile_form, service_formset, link_formset, ]) context = { 'object': profile, 'action_form': ActionForm(), 'profile_form': profile_form, 'user_form': user_form, 'service_formset': service_formset, 'link_formset': link_formset, 'form_errors': form_errors, } else: profile = Profile.objects.get(user=request.user) link_formset = LinkFormSet(instance=profile) service_formset = ServiceFormSet(instance=profile) context = { 'object': profile, 'action_form': ActionForm(), 'profile_form': ProfileForm(instance=profile), 'user_form': UserForm(instance=request.user), 'service_formset': service_formset, 'link_formset': link_formset } return render_to_response(template_name, context, context_instance=RequestContext(request))
def update_profile(request): if request.method == 'POST': user_form = UserForm(request.POST, instance=request.user) profile_form = ProfileForm(request.POST, instance=request.user.profile) if user_form.is_valid() and profile_form.is_valid(): user_form.save() profile_form.save() messages.success(request, ('Ваш профиль был успешно обновлен!')) return redirect('profile') else: messages.error(request, ('Пожалуйста, исправьте ошибки.')) else: user_form = UserForm(instance=request.user) profile_form = ProfileForm(instance=request.user.profile) return render(request, 'profile.html', { 'user_form': user_form, 'profile_form': profile_form })
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( commit=False) # setting password done in forms.py user.alias = user.username user.save() # extra password thing # 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. :( # end extra password thing profile = profile_form.save(commit=False) if Location.objects.count() > 0: profile.location = Location.objects.all()[0] profile.user = user profile.save() user = authenticate(username=request.POST['username'], password=request.POST['password']) login(request, user) messages.add_message( request, messages.SUCCESS, "Congratulations, {}, on creating your new account! You are now logged in." .format(user.username)) send_mail("Welcome to Share Lockers", """\ {}, Your account on sharelockers.come has been created! \ We look forward to seeing what you have to share. \ You might start by stocking some items to sell, or by adding items you have \ at home which you would be willing to sell. -ShareLockers Team""".format(user.username), settings.EMAIL_HOST_USER, [user.email], fail_silently=settings.EMAIL_SILENT) return redirect('view_index') return render(request, "profiles/register.html", { 'user_form': user_form, 'profile_form': profile_form, })
def register(request): """ Registration page which shows a form for the user to complete """ 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) if user_form.cleaned_data['is_developer']: user.developer.active = True add_default_service(user.developer) if user_form.cleaned_data['is_provider']: user.provider.active = True # When a new provider is registered, # a new rabbitmq user should be added to the system initialize_rabbitmq_user(user) # TODO: create hyperledger fabric user if USE_FABRIC: r = fabric.invoke_new_monetary_account(user.username, '700') if 'jwt expired' in r.text or 'jwt malformed' in r.text or 'User was not found' in r.text: token = fabric.register_user() r = fabric.invoke_new_monetary_account(user.username, '700', token = token) user.save() user = authenticate(username=user_form.cleaned_data['username'], password=user_form.cleaned_data['password']) login(request, user) messages.success(request, "Successful Login") registered = True if user_form.cleaned_data['is_provider']: return render(request, 'providers_app/index.html') else: print(user_form.errors) else: user_form = UserForm() return render(request, 'profiles/registration.html', {'user_form': user_form, 'registered': registered})
def get_object(self, queryset=None): user = get_user_model().objects.get( pk=self.request.session['_auth_user_id']) return UserForm(instance=user)
def edit_profile(request, form_class=ProfileForm, success_url=None, template_name='profiles/edit_profile.html', extra_context=None): """ Edit the current user's profile. If the user does not already have a profile (as determined by ``User.get_profile()``), a redirect will be issued to the :view:`profiles.views.create_profile` view; if no profile model has been specified in the ``AUTH_PROFILE_MODULE`` setting, ``django.contrib.auth.models.SiteProfileNotAvailable`` will be raised. **Optional arguments:** ``extra_context`` A dictionary of variables to add to the template context. Any callable object in this dictionary will be called to produce the end result which appears in the context. ``form_class`` The form class to use for validating and editing the user profile. This form class must operate similarly to a standard Django ``ModelForm`` in that it must accept an instance of the object to be edited as the keyword argument ``instance`` to its constructor, and it must implement a method named ``save()`` which will save the updates to the object. If this argument is not specified, this view will use a ``ModelForm`` generated from the model specified in the ``AUTH_PROFILE_MODULE`` setting. ``success_url`` The URL to redirect to following a successful edit. If not specified, this will default to the URL of :view:`profiles.views.profile_detail` for the profile object being edited. ``template_name`` The template to use when displaying the profile-editing form. If not specified, this will default to :template:`profiles/edit_profile.html`. **Context:** ``form`` The form for editing the profile. ``profile`` The user's current profile. **Template:** ``template_name`` keyword argument or :template:`profiles/edit_profile.html`. """ try: profile_obj = request.user.get_profile() except ObjectDoesNotExist: return HttpResponseRedirect(reverse('profiles_create_profile')) # # See the comment in create_profile() for discussion of why # success_url is set up here, rather than as a default value for # the argument. # if success_url is None: success_url = reverse('profiles_profile_detail', kwargs={ 'username': request.user.username }) if form_class is None: form_class = utils.get_profile_form() if request.method == 'POST': profile_form = form_class(data=request.POST, files=request.FILES, instance=profile_obj) user_form = UserForm(data=request.POST, files=request.FILES, instance=request.user) if user_form.is_valid() and profile_form.is_valid(): user_form.save() profile_form.save() return HttpResponseRedirect(success_url) else: user_form = UserForm(instance=request.user) profile_form = form_class(instance=profile_obj) 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, { 'user_form': user_form, 'profile_form': profile_form, 'profile': profile_obj, }, context_instance=context)
def create_profile(request, form_class=ProfileForm, success_url=None, template_name='profiles/create_profile.html', extra_context=None): """ Create a profile for the current user, if one doesn't already exist. If the user already has a profile, as determined by ``request.user.get_profile()``, a redirect will be issued to the :view:`profiles.views.edit_profile` view. If no profile model has been specified in the ``AUTH_PROFILE_MODULE`` setting, ``django.contrib.auth.models.SiteProfileNotAvailable`` will be raised. **Optional arguments:** ``extra_context`` A dictionary of variables to add to the template context. Any callable object in this dictionary will be called to produce the end result which appears in the context. ``form_class`` The form class to use for validating and creating the user profile. This form class must define a method named ``save()``, implementing the same argument signature as the ``save()`` method of a standard Django ``ModelForm`` (this view will call ``save(commit=False)`` to obtain the profile object, and fill in the user before the final save). If the profile object includes many-to-many relations, the convention established by ``ModelForm`` of using a method named ``save_m2m()`` will be used, and so your form class should also define this method. If this argument is not supplied, this view will use a ``ModelForm`` automatically generated from the model specified by ``AUTH_PROFILE_MODULE``. ``success_url`` The URL to redirect to after successful profile creation. If this argument is not supplied, this will default to the URL of :view:`profiles.views.profile_detail` for the newly-created profile object. ``template_name`` The template to use when displaying the profile-creation form. If not supplied, this will default to :template:`profiles/create_profile.html`. **Context:** ``form`` The profile-creation form. **Template:** ``template_name`` keyword argument, or :template:`profiles/create_profile.html`. """ try: profile_obj = request.user.get_profile() return HttpResponseRedirect(reverse('profiles_edit_profile')) except ObjectDoesNotExist: pass # # We set up success_url here, rather than as the default value for # the argument. Trying to do it as the argument's default would # mean evaluating the call to reverse() at the time this module is # first imported, which introduces a circular dependency: to # perform the reverse lookup we need access to profiles/urls.py, # but profiles/urls.py in turn imports this module. # if success_url is None: success_url = reverse('profiles_profile_detail', kwargs={ 'username': request.user.username }) if form_class is None: form_class = utils.get_profile_form() if request.method == 'POST': profile_form = form_class(data=request.POST, files=request.FILES) user_form = UserForm(data=request.POST, files=request.FILES, instance=request.user) if user_form.is_valid() and profile_form.is_valid(): user_obj = user_form.save() profile_obj = profile_form.save(commit=False) profile_obj.user = request.user profile_obj.save() if hasattr(profile_form, 'save_m2m'): profile_form.save_m2m() return HttpResponseRedirect(success_url) else: user_form = UserForm(instance=request.user) profile_obj = UserProfile.objects.create(user=request.user) profile_form = form_class(instance=profile_obj) 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, { 'user_form': user_form, 'profile_form': profile_form}, context_instance=context)
def test_email_validation_not_raises_error(self, admin_user): """Test that error won't be raisedif passed email is user email.""" form = UserForm(instance=admin_user) form.cleaned_data = {'email': admin_user.email} email = form.clean_email() assert email == admin_user.email
def test_email_validation_not_raises_error_if_available(self, admin_user): """Test that error won't be raised if passed email is available""" form = UserForm(instance=admin_user) form.cleaned_data = {'email': '*****@*****.**'} email = form.clean_email() assert email == '*****@*****.**'