def test_profile_forms(self): user_form_data = {'username': '******', 'first_name': 'dave', 'last_name': 'Bright', 'email':'*****@*****.**', 'password':'******', 'password_confirm':'pwd123', } user_form = UserForm(data=user_form_data) if not user_form.is_valid(): print user_form.errors else: self.assertTrue(user_form.is_valid()) user = user_form.save(commit=False) user.set_password(user.password) user.save() profile_form_data = { 'birth_year':1983, 'captcha_0':'dummy-value', 'captcha_1':'PASSED' } profile_form = UserProfileForm(data=profile_form_data) if not profile_form.is_valid(): print profile_form.errors else: profile = profile_form.save(commit=False) profile.user = user profile.save()
def test_password_no_match(self): user_form_data = {'username': '******', 'first_name': 'martin', 'last_name': 'Bright', 'email':'*****@*****.**', 'password':'******', 'password_confirm':'pwd123x', } user_form = UserForm(data=user_form_data) if not user_form.is_valid(): pass # print user_form.errors else: self.assertTrue(user_form.is_valid()) user = user_form.save(commit=False) user.set_password(user.password) profile_form_data = { 'birth_year':1983, 'captcha_0':'dummy-value', 'captcha_1':'PASSED' } profile_form = UserProfileForm(data=profile_form_data) self.assertFalse(profile_form.is_valid(), "test_password_no_match not success")
def add_teammate(request, slug): user = request.user friends = AccountDetails.get_my_friends(user) if len(friends) == 0: return render(request, 'friends/no_friends.html') event = Event.objects.get(slug=slug) form = UserForm(request.POST or None) context = {'form': form} filtered_users = [] if request.method == 'POST': if form.is_valid(): username = request.POST.get('username') users = User.objects.all().filter(username__icontains=username) for user in users: if AccountDetails.is_my_friend(request.user, user): if AccountDetails.objects.filter(user=user): details = AccountDetails.objects.get(user=user) user.details = details user.my_friend = AccountDetails.is_my_friend( request.user, user) filtered_users.append(user) context = {'users': filtered_users, 'form': form, 'event': event} return render(request, 'events/add_teammate.html', context)
def dashboard(request): user = request.user try: user_profile = UserProfile.objects.get(user=user) except Exception: _profile(user) user_profile = UserProfile.objects.get(user=user) orders = Order.objects.order_by('-created_at').filter(user_id=request.user.id, is_ordered=True) orders_count = orders.count() if request.method == 'POST': user_form = UserForm(request.POST, instance=request.user) profile_form = UserProfileForm(request.POST, request.FILES, instance=user_profile) if user_form.is_valid() and profile_form.is_valid(): user_form.save() profile_form.save() messages.success(request, 'Ваши данные успешно обновлены!') return redirect('dashboard') else: user_form = UserForm(instance=request.user) profile_form = UserProfileForm(instance=user_profile) context = { 'orders': orders, 'orders_count': orders_count, 'user_form': user_form, 'profile_form': profile_form, 'user_profile': user_profile, } return render(request, 'accounts/dashboard.html', context)
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 profile.save() registered = True # return render(request,'accounts/registration_welcome.html') else: return render( request, 'accounts/registration.html', { 'user_form': user_form, 'profile_form': profile_form, 'registered': registered, 'user_error': user_form.errors, 'profile_error': profile_form.errors }) else: user_form = UserForm() profile_form = UserProfileInfoForm() return render( request, 'accounts/registration.html', { 'user_form': user_form, 'profile_form': profile_form, 'registered': registered })
def employee_create_view(request): error_dict = {} if request.method == 'POST': employee_form = EmployeeForm(request.POST, request.FILES) form = UserForm(request.POST) if employee_form.is_valid() and form.is_valid(): user = form.save() instance = employee_form.save(commit=False) owner = Owner.objects.get(user=request.user) instance.owner = owner instance.user = user instance.save() messages.success(request, 'Employee successfully registered.') return redirect("employees:list") else: error_dict = { 'status': 'form-invalid', 'form_errors': form.errors, 'emp_errors': employee_form.errors } else: employee_form = EmployeeForm() form = UserForm() context = { 'employee_form': employee_form, 'form': form, } if request.is_ajax(): json_data = {'error_dict': error_dict} return JsonResponse(json_data) return render(request, 'employees/create-employee.html', context)
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() # We need to authenticate a user, otherwise the system will show him the 'register' route username = user_form.cleaned_data.get('username') password = user_form.cleaned_data.get('password1') user = authenticate(username=username, password=password) login(request, user) ''' The best practice of authentication is to redirect a user to a new page. If we try to stay at the same page, we get POST requests when an auth form is not filled completely and we try to reload the page. We expect GET requests but get POST ones. ''' return redirect(reverse('thanks')) else: print(user_form.errors) else: if request.user.is_authenticated: registered = True user_form = UserForm() return render(request, 'registration.html', {'user_form': user_form, 'registered': registered})
def edit_my_profile(request): u = request.user try: profile = u.get_profile() except UserProfile.DoesNotExist: profile = None if request.method == 'POST': POST = request.POST.copy() POST['user'] = u.id profile_form = UserProfileForm(POST, request.FILES, instance=profile) user_form = UserForm(request.POST, request.FILES, instance=u) if user_form.is_valid() and profile_form.is_valid(): u = user_form.save() profile = profile_form.save() profile.user = u request.user.message_set.create(message="Your Profile was updated") return HttpResponseRedirect(profile.get_absolute_url()) else: user_form = UserForm(instance=u) if profile: profile_form = UserProfileForm(instance=profile) else: profile_form = UserProfileForm(initial={'user':request.user}) return render(request, 'edit_profile.html', {'profile_form':profile_form, 'user_form':user_form})
def register(request): context = RequestContext(request) registered = False 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.set_password(user.password) 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 = UserProfileForm() #Render the template depending on the context return render_to_response( 'register.html', { 'user_form': user_form, 'profile_form': profile_form, 'registered': registered }, context)
def post(self, request, *args, **kwargs): # Attempt to grab information from the raw form information. # Note that we make use of both UserForm and PublicForm. form_args = { 'data': request.POST, } user_form = UserForm(data=request.POST, instance=request.user) instance = UserProfile.objects.get(user=request.user) kwargs.setdefault('curruser', instance) profile_form = UserProfileForm(data=request.POST, instance=instance) # 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 sort out the Public 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 Public model. if 'picture' in request.FILES: profile.picture = request.FILES['picture'] # Now we save the Public model instance. profile.save() # 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 kwargs.setdefault("user_form", self.user_form_class(instance=instance.user)) kwargs.setdefault("profile_form", self.profile_form_class(instance=instance)) return super(Profile, self).get(request, *args, **kwargs)
def signup(request): context = {} context['title'] = _('Register') user = User() if request.user.is_authenticated(): return redirect('accounts_accounts') userProfile = UserProfile() if request.method == 'POST': userForm = UserForm(request.POST, instance=user) userProfileForm = UserProfileForm(request.POST, instance=userProfile) if userForm.is_valid() and userProfileForm.is_valid(): userData = userForm.cleaned_data user.username = userData['username'] user.first_name = userData['first_name'] user.last_name = userData['last_name'] user.email = userData['email'] user.set_password(userData['password']) user.save() userProfile = user.get_profile() userProfileData = userProfileForm.cleaned_data userProfile.gender = userProfileData['gender'] userProfile.birthday = userProfileData['birthday'] userProfile.save() user = authenticate(username=userData['username'], password=userData['password']) login(request, user) return redirect('accounts_accounts') else: userForm = UserForm(instance=user) userProfileForm = UserProfileForm(instance=userProfile) context['userForm'] = userForm context['userProfileForm'] = userProfileForm return render_to_response('accounts/register.html', context, context_instance=RequestContext(request))
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: print('found it') 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, 'accounts/registration.html', { 'user_form': user_form, 'profile_form': profile_form, 'registered': registered })
def contrainer(request, urlloc): if request.method == "POST": form = UserForm(request.POST, request.FILES) if form.is_valid(): compte = form.save() cheekin_v = Checkin() doc = urlloc.split("a") locx = doc[0].replace("p", ".") locy = doc[1].replace("p", ".") cheekin_v.username = User.objects.get(username=compte.username) cheekin_v.x = Decimal(locx) cheekin_v.y = Decimal(locy) cheekin_v.cheek_date = timezone.now() cheekin_v.save() request.session['username'] = newuser.id # compte = User.objects.all()[User.objects.count()-1] compte = User.objects.get(id=request.session['username']) cheekin_compte = Checkin.objects.get(username=compte) cheekin_view = Checkin.objects.all().order_by('-cheek_date') vx = float(cheekin_compte.x) vy = float(cheekin_compte.y) aux = [] # user in space of 2km of your current compte for d in cheekin_view: m = float(d.x) n = float(d.y) if vx - 0.2 < m < vx + 0.2 and vy - 0.2 < n < vy + 0.2: f = User.objects.filter(username=d.username) aux.append(f) return render(request, 'space/index.html', { 'vuser': aux, 'last': compte, 'cheekin': cheekin_view, 'x': urlloc })
def profile(request): form = UserForm(instance=request.user) pwd_form = PasswordChangeForm(request.user) associations = {'twitter': False, 'google_oauth2': False, 'github': False} for association in request.user.social_auth.all(): associations[association.provider.replace('-', '_')] = True if request.method == 'POST': if request.POST.get('do_password'): pwd_form = PasswordChangeForm(request.user, request.POST) if pwd_form.is_valid(): pwd_form.save() messages.success(request, "Password successfully changed.") else: messages.error(request, "Could not update password. See errors below.") elif request.POST.get('do_profile'): form = UserForm(request.POST, instance=request.user) if form.is_valid(): form.save() messages.success(request, 'Profile successfully updated.') else: messages.error(request, 'You have an error in your profile. See below errors.') else: messages.error(request, "Er, something weird happened. Contact the site admin.") return render(request, 'accounts/profile.html', locals())
def user_profile(request): """User's profile page with auction results and profile form to update""" current_auctions = Auction.objects.filter( winning_bidder=request.user.pk, auction_end_time__gte=timezone.now()) past_paid_auctions = Auction.objects.filter( winning_bidder=request.user.pk, auction_end_time__lt=timezone.now(), paid=True) past_unpaid_auctions = Auction.objects.filter( winning_bidder=request.user.pk, auction_end_time__lt=timezone.now(), paid=False) 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, 'Your profile was successfully updated.') return redirect('profile.html') else: messages.error(request, 'Please correct the error below.') 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, 'current_auctions': current_auctions, 'past_paid_auctions': past_paid_auctions, 'past_unpaid_auctions': past_unpaid_auctions })
def registration(request): registered = False 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() profile = profile_form.save(commit=False) profile.user = user if 'picture' in request.FILES: profile.picture = request.FILES['picture'] profile.save() registered = True else: print user_form.errors, profile_form.errors else: user_form = UserForm() profile_form = UserProfileForm() return render(request, 'accounts/register.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered} )
def userinfo(request): if not request.session.get('is_login'): return HttpResponseRedirect(reverse('accounts:login')) user_id = request.session.get('user_id') user = User.objects.get(id=user_id) likes = user.likerecord_set.all() pars = user.parrecord_set.all() if user.groups_set.filter(user_id=user_id): group = user.groups_set.get(user_id=user_id) isgroup = group.permitted group_name = group.group_name else: isgroup = False if request.method != 'POST': form = UserForm(instance=user) else: form = UserForm(instance=user, data=request.POST) if form.is_valid(): username = form.cleaned_data['username'] email = form.cleaned_data['email'] if (user.username != username) and (User.objects.filter( username=username)): message = 'username already exists' return render(request, 'accounts/userinfo.html', locals()) else: if (User.objects.filter( email=email)) and (user.email != email): message = 'email address already exists' return render(request, 'accounts/userinfo.html', locals()) user.username = username user.email = email user.save() request.session['user_name'] = username notice = 'you have successfully edit your information' return render(request, 'accounts/userinfo.html', locals())
def register(request): """ user registration form: GET/POST /registration """ 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(): human = True user = user_form.save(commit=False) user.set_password(user.password) user.save() profile = profile_form.save(commit=False) profile.user = user profile.save() # save user in session login(request, user) logger.info('user {0} registered successfully'.format(user.username)) request.session['username'] = user.name return HttpResponseRedirect(reverse('profile')) else: print user_form.errors # raise Http404("Your registration is failed.") else: user_form = UserForm() profile_form = UserProfileForm() context = {'user_form': user_form, 'profile_form': profile_form}; return render(request, 'register.html', context);
def create_company(request): if request.method == 'POST': form = UserForm(request.POST) if form.is_valid(): address = Address.objects.create() # Create user user = form.save(commit=False) user.is_company = True user.address = address user.save() # Add the user to company group user_group = Group.objects.get(name='company') user_group.user_set.add(user) # Create company Company.objects.create(website=form.cleaned_data['website'], user=user) messages.info(request, "Company created successfully!") else: messages.error(request, 'Something is Wrong!') return HttpResponseRedirect('/accounts/login/') else: form = UserForm() context_dict = {'form': form} return render(request, 'create_company.html', context_dict)
def accounts_add(request): error = "" if request.method == "POST": groups = request.POST.getlist('groups') email = request.POST.get('email') email = MyUser.objects.filter(email=email) form = UserForm(request.POST) if email: error = u'该账号已存在!' else: if form.is_valid(): user = form.save(commit=False) user.set_password(form.cleaned_data['password']) user.save() user.groups = Group.objects.get(id=1) return HttpResponseRedirect(reverse('user_user')) else: form = UserForm() groups = get_groups(request) print(groups) request.breadcrumbs( (('首页', '/'), ('用户列表', reverse('user_user')), ('添加用户', reverse('user_add')))) return render(request, 'accounts/user/user_add.html', { 'request': request, 'form': form, 'error': error, 'groups': groups })
def registration(request): registered = False 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() profile = profile_form.save(commit=False) profile.user = user if 'picture' in request.FILES: profile.picture = request.FILES['picture'] profile.save() registered = True else: print user_form.errors, profile_form.errors else: user_form = UserForm() profile_form = UserProfileForm() return render( request, 'accounts/register.html', { 'user_form': user_form, 'profile_form': profile_form, 'registered': registered })
def signup_user(request): if request.method == 'GET': context = { 'user_form': UserForm(), 'profile_form': UserProfileForm(), } return render(request, 'accounts/signup.html', context) else: user_form = UserForm(request.POST) profile_form = UserProfileForm(request.POST, request.FILES) if user_form.is_valid() and profile_form.is_valid(): user = user_form.save() profile = profile_form.save(commit=False) profile.user = user group = Group.objects.get(name='customer') user.groups.add(group) profile.save() login(request, user) return redirect('user profile') context = { 'user_form': user_form, 'profile_form': profile_form, } return render(request, 'accounts/signup.html', context)
def register(request): registered = False profile = UserProfile.objects.get(user=request.user) 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.set_password(user.password) 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 = UserProfileForm() return render(request, 'accounts/reg.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered, 'profile': profile,} )
def profile_edit(request): profile_ = Profile.objects.get( user=request.user ) # get profile qui a user(dans profile) = au user request if request.method == 'POST': userform = UserForm(request.POST, instance=request.user) profileform = ProfileForm( request.POST, request.FILES, instance=profile_) # request.FILES : pour uplaod file if userform.is_valid() and profileform.is_valid(): userform.save( ) # save user directement mais le profile nécessité la suivante myform = profileform.save( commit=False) # s'assurer que le profile est relié au user myform.user = request.user # s'assurer que le profile est relié au user myform.save() # save profile messages.success( request, 'updated') # qui sera affiché dans redirect template return redirect('accounts:profile') else: # (affichage) userform = UserForm( instance=request.user ) # request.user = data du user connecté (affichage) profileform = ProfileForm( instance=profile_ ) # profile_ = profile du user connecté (affichage) return render(request, 'accounts/profile/edit_profile.html', { 'userform': userform, 'profileform': profileform })
def register(request): if request.method == 'POST': u_form = UserForm(request.POST) p_form = ProfileForm(request.POST) if u_form.is_valid() and p_form.is_valid(): user = u_form.save() gender = p_form.cleaned_data.get('gender') date_of_birth = p_form.cleaned_data.get('date_of_birth') contact_number = p_form.cleaned_data.get('contact_number') author = AuthorProfile.objects.create( author=user, gender=gender, date_of_birth=date_of_birth, contact_number=contact_number) p_form = ProfileForm(request.POST, instance=author) p_form.save() messages.success(request, 'Your account has been created!') return redirect('login') else: u_form = UserForm() p_form = ProfileForm() context = {'u_form': u_form, 'p_form': p_form} return render(request, 'accounts/register.html', context)
def update_profile(request): """ Fetch data from user and user profile and render it on the form. Update both models. """ if not request.user.is_authenticated: return redirect('login') else: if request.method == 'POST': user_form = UserForm(request.POST, instance=request.user) profile_form = ProfileForm(request.POST, request.FILES, instance=request.user.profiles) if user_form.is_valid() and profile_form.is_valid(): user_form.save() profile_form.save() messages.success(request, ('Your profile has been updated successfully!')) return redirect('user_profile') else: messages.error(request, ('Please correct the error below.')) else: user_form = UserForm(instance=request.user) profile_form = ProfileForm(instance=request.user.profiles) context = { 'user_form': user_form, 'profile_form': profile_form, 'title': 'Update', 'profile': 'profile' } return render(request, 'update_profile.html', context)
def register(request): registered = False if request.method == 'POST': user_form = UserForm(data=request.POST) profile_form = UserProfileInfoForm(data=request.POST) #image = QRForm(data=request.POST) if user_form.is_valid() and profile_form.is_valid(): user = user_form.save() user.set_password(user.password) user.save() user = authenticate(username=user_form.cleaned_data['username'], password=user_form.cleaned_data['password']) profile = profile_form.save(commit=False) profile.user = user profile.save() registered = True login(request, user) else: print(user_form.errors, profile_form.errors) else: user_form = UserForm() profile_form = UserProfileInfoForm() return render( request, 'accounts/templates/registration/register.html', { 'user_form': user_form, 'profile_form': profile_form, 'registered': registered })
def post(self, *args, **kwargs): data = self.request.POST # Load User and Profile forms form = UserForm(data) profileform = UserProfileForm(data) # Calls the validation method of the two model forms if form.is_valid() and profileform.is_valid(): # create and save user object user = form.save() # create and save profile object # assign `user` as a fk of the user field in the profile object profile = profileform.save(commit=False) profile.user = user profile.save() # authenticate user self.login_user_no_password(user) # Redirect to dashboard return HttpResponseRedirect(reverse('dashboard')) else: self.context['form'] = form self.context['profileform'] = profileform return render(self.request, self.template_name, self.context)
def add_operator(request): is_login = True user = request.user form = UserForm() if request.method == 'POST': form = UserForm(request.POST) if form.is_valid(): new_user = User.objects.create_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'], password = form.cleaned_data['password'], ) request.session['user_created'] = json.dumps(True) request.session['user_created_id'] = json.dumps(new_user.id) return redirect("/accounts/operatorslist/") context = { "header": { "title": "Добавить оператора" }, "is_login": is_login, "user": user, "form": form } template = loader.get_template('accounts/addaccount.html') return HttpResponse(template.render(context, request))
def create_doctor_view(request): user_form = UserForm() doctor_form = DoctorForm() context = {"user_form":user_form,"doctor_form":doctor_form} if request.method == "POST": user_form = UserForm(request.POST) doctor_form = DoctorForm(request.POST) if user_form.is_valid() and doctor_form.is_valid(): user = user_form.save() user.set_password(user.password) user.save() doctor = doctor_form.save(commit=False) doctor.user = user if 'profile_picture' in request.FILES: doctor.profile_picture = request.FILES['profile_picture'] doctor.save() return HttpResponseRedirect(reverse('accounts:login')) else: return HttpResponse("Invalid form submission") return render(request,'doctor/register_doctor.html',context=context)
def register(request): 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.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() else: print user_form.errors, profile_form.errors else: user_form = UserForm() profile_form = UserProfileForm() context = {'user_form' : user_form, 'profile_form' : profile_form} return render_to_response('accounts/register.html', context, context_instance=RequestContext(request))
def update_profile(request): if request.method == 'POST': user_form = UserForm(request.POST, instance=request.user) profile_form = UserChForm(request.POST, request.FILES, instance=request.user.profile) # git = request.user.profile.github # print(git) # git = re.match(git, "https://github.com/") # print(git, 'it works!!!') # if git == match.group(0): # print(match.group(0), 'it works!') if user_form.is_valid() and profile_form.is_valid(): user_form.save() profile_form.save() # messages.success(request, _('Your profile was successfully updated!')) return redirect('accounts:user_list') else: user_form = UserForm(instance=request.user) profile_form = UserChForm(instance=request.user.profile) return render( request, 'user_update.html', { 'user_form': user_form, 'profile_form': profile_form, # 'user_obj': request.user })
def edit_user(request): profile = User_Profile.objects.get(User_associated=request.user) user = User.objects.get(id=request.user.id) # img = None if request.method == "POST": profileForm = ProfileForm(request.POST, instance=profile, prefix="profile_form") userForm = UserForm(request.POST, instance=user, prefix="user_form") # passwordForm = PasswordChangeForm(data=request.POST, user=request.user, prefix="password_form") if profileForm.is_valid() and userForm.is_valid(): profileForm.save() userForm.save() # passwordForm.save() else: profileForm = ProfileForm(prefix="profile_form", instance=profile, initial={"Degree": profile.Degree, "Year_first_enrolled": profile.Year_first_enrolled,}) userForm = UserForm(prefix="user_form", instance=user, initial={'username': user.username, 'email': user.email, 'first_name': user.first_name, 'last_name': user.last_name}) return render_to_response("accounts/settings.html", {"profile_form": profileForm, "user_form": userForm}, context_instance=RequestContext(request))
def edit_profile(request): """ Create a view that allows us to edit your profile """ user = request.user profile = user.profile if request.method == 'POST': # create a form instance and populate it with data from the request: userForm = UserForm(request.POST) profileForm = ProfileForm(request.POST, request.FILES, instance=profile) # check whether it's valid: if userForm.is_valid() and profileForm.is_valid(): # Save User model fields user.first_name = request.POST['first_name'] user.last_name = request.POST['last_name'] user.email = request.POST['email'] user.save() profile = profileForm.save(commit=False) profile.save() # if a GET (or any other method): create a blank form else: userForm = UserForm(instance=user) profileForm = ProfileForm(instance=profile) return render(request, 'profile.html', { 'userForm': userForm, 'profileForm': profileForm })
def donation_request(request): donation_form = DonationForm(data=request.POST or None) user_form = UserForm(data=request.POST or None) if donation_form.is_valid(): donation = donation_form.save(commit=False) user = None send_mail_new_user = False if request.user.is_authenticated(): user = request.user elif user_form.is_valid(): user = user_form.save() send_mail_new_user = True if user: donation.user = user donation.save() send_mail_compatible_donors.delay(donation.id) if send_mail_new_user: send_signup_mail.delay(user.name, user.email) messages.add_message( request, messages.SUCCESS, _(u'Sua solicitação foi gravada com sucesso! Vamos procurar doadores compatíveis com o tipo sanguíneo informado. Você pode ajudar compartilhando este link com amigos através das redes sociais.' )) return redirect('donation_details', donation_id=donation.id) return render_to_response('donations/donation_request.html', { 'donation_form': donation_form, 'user_form': user_form }, context_instance=RequestContext(request))
def profile(request): form = UserForm(instance=request.user) if request.method == 'POST': form = UserForm(instance=request.user, data=request.POST) if form.is_valid(): form.save() return render(request, 'profile.html', { 'form': form, 'locations': Location.objects.all()})
def user_profile(request): profile = request.user.get_profile() if request.method == "POST": # Read params form = ProfileForm(request.POST, instance=profile) subscriptionform = SubscriptionForm(request.POST, instance=profile) userform = UserForm(request.POST, instance=request.user) if appsettings.DEMO_SERVER and request.user.username == "demo": messages.warning(request, _("You can not change demo profile on the demo server.")) return redirect("profile") if form.is_valid() and userform.is_valid() and subscriptionform.is_valid(): # Save changes form.save() subscriptionform.save() userform.save() # Change language set_lang(request.user, request=request, user=request.user) # Redirect after saving (and possibly changing language) response = redirect("profile") # Set language cookie and activate new language (for message below) lang_code = profile.language response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code) translation.activate(lang_code) messages.info(request, _("Your profile has been updated.")) return response else: form = ProfileForm(instance=profile) subscriptionform = SubscriptionForm(instance=profile) userform = UserForm(instance=request.user) social = request.user.social_auth.all() social_names = [assoc.provider for assoc in social] new_backends = [x for x in load_backends(BACKENDS).keys() if x == "email" or x not in social_names] response = render_to_response( "accounts/profile.html", RequestContext( request, { "form": form, "userform": userform, "subscriptionform": subscriptionform, "profile": profile, "title": _("User profile"), "licenses": Project.objects.exclude(license=""), "associated": social, "new_backends": new_backends, }, ), ) response.set_cookie(settings.LANGUAGE_COOKIE_NAME, profile.language) return response
def register(request): context = RequestContext(request) registered = False 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.set_password(user.password) 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 = UserProfileForm() #Render the template depending on the context return render_to_response('register.html', {'user_form':user_form,'profile_form':profile_form, 'registered':registered}, context )
def test_failure_user_form(self): """正常ではない入力を行いエラーになることを検証""" print('Test Case 4-2') print() user = User() form = UserForm(data={'username': '', 'password': '******'}, instance=user) self.assertTrue(not(form.is_valid()))
def test_userform_data_is_valid(self): form = UserForm(data={ 'username': '******', 'email': '*****@*****.**', 'password': '******' }) self.assertEqual(form.is_valid(), True)
def test_success_user_form(self): """正常な入力を行いエラーにならないことを検証""" print('Test Case 4-1') print() user = User() form = UserForm(data={'username': '******', 'password': '******'}, instance=user) self.assertTrue(form.is_valid())
def register(request): # Like before, get the request's context. context = RequestContext(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_to_response( 'register.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered}, context)
def post(self, request): profile_form = UserForm(request.POST, request.FILES, instance=request.user) if profile_form.is_valid(): profile_form.save() return redirect('accounts_profile') else: return self._render(request, profile_form=profile_form)
def register_view(request): form = UserForm() if request.method == 'POST': form = UserForm(request.POST) if form.is_valid(): form.save() return HttpResponse('<h2>Thank you! You are now registered!</h2>') return render(request, 'accounts/registration_form.html', {'form': form})
def register(request): if request.method == 'POST': uf = UserForm(request.POST) if uf.is_valid(): user = uf.save() return HttpResponseRedirect('main') else: uf = UserForm() return render_to_response('register.html', {'form': uf}, RequestContext(request))
def post(self, request): form = UserForm(request.POST, instance=request.user) if form.is_valid(): request.user.save() messages.add_message(request, messages.SUCCESS, "You profiles was updated successfully!") else: for error in form.errors: messages.add_message(request, messages.ERROR, error) return redirect('profile')
def edit_profile(request): if request.method == 'POST': form = UserForm(request.POST, instance=request.user) if form.is_valid(): form.save() return redirect('account') else: form = UserForm(instance=request.user) return render(request, 'registration/edit_profile.html', {'form':form})
def register(request): context = RequestContext(request) registered = False 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.set_password(user.password) user.is_active = False username = user.username email = user.email salt = hashlib.sha1(str(random.random())).hexdigest()[:5] activation_key = hashlib.sha1(salt + email).hexdigest() key_expires = datetime.datetime.today() + datetime.timedelta(2) user.save() profile = profile_form.save(commit=False) profile.user = user profile.activation_key = activation_key profile.key_expires = key_expires profile.save() registered = True # Send email with activation key email_subject = 'Account confirmation' email_body = "Hey %s, thanks for signing up. To activate your account, click this link within \ 48hours http://127.0.0.1:8000/accounts/confirm/%s" % (username, activation_key) send_mail(email_subject, email_body, '*****@*****.**', [email], fail_silently=False) else: print user_form.errors, profile_form.errors else: user_form = UserForm() profile_form = UserProfileForm() # Render the template depending on the context. return render_to_response( 'accounts/register.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered}, context)
def add_user(request): if request.user.is_authenticated and request.user.is_superuser: form = UserForm() if request.method == 'POST': form = UserForm(data=request.POST) username = request.POST['username'] email = request.POST['email'] if form.is_valid(): user = form.save(commit=False) return {'form':form} return render_to_response("home.html",{'404':'404'}, context_instance=RequestContext(request))
def signup_teacher(request): teacher_form = TeacherForm(request.POST or None) user_form = UserForm(request.POST or None) if request.method == "POST": if teacher_form.is_valid() and user_form.is_valid(): user = user_form.save() teacher = teacher_form.save(commit=False) teacher.user = user teacher.save() return redirect("index") return render(request, "signup_teacher.html", {"form": user_form, "teacher_form": teacher_form})
def user_profile(request): profile = request.user.get_profile() if request.method == "POST": # Read params form = ProfileForm(request.POST, instance=profile) subscriptionform = SubscriptionForm(request.POST, instance=profile) userform = UserForm(request.POST, instance=request.user) if form.is_valid() and userform.is_valid() and subscriptionform.is_valid(): # Save changes form.save() subscriptionform.save() userform.save() # Change language set_lang(request.user, request=request, user=request.user) # Redirect after saving (and possibly changing language) response = HttpResponseRedirect(reverse("profile")) # Set language cookie and activate new language (for message below) lang_code = profile.language response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code) translation.activate(lang_code) messages.info(request, _("Your profile has been updated.")) return response else: form = ProfileForm(instance=profile) subscriptionform = SubscriptionForm(instance=profile) userform = UserForm(instance=request.user) response = render_to_response( "profile.html", RequestContext( request, { "form": form, "userform": userform, "subscriptionform": subscriptionform, "profile": profile, "title": _("User profile"), "licenses": Project.objects.exclude(license=""), }, ), ) response.set_cookie(settings.LANGUAGE_COOKIE_NAME, profile.language) return response
def registration(request): 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. 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 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, 'accounts/register.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered} )
def register(request): if request.POST: form = UserForm(request.POST) if form.is_valid(): username = request.POST['username'] # screenname = request.POST['screenname'] password = request.POST['password'] new_user = User.objects._create_user(username=username, password=password, is_superuser=False) new_user.is_active = True new_user.save() return render(request, 'accounts/login.html') else: form = UserForm() return render(request, 'accounts/register.html', {'form': form})
def register(request): # Like before,get the request's context. context = RequestContext(request) registered = False if request.method == 'POST': user_form = UserForm(data=request.POST) profile_form = UserProfileForm(data=request.POST) # 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() # hash the password user.set_password(user.password) user.save() profile = profile_form.save(commit=False) profile.user = user # Did the user provide a profile picture? if 'picture' in request.FILES: profile.picture = request.FILES['picture'] # save UserProfile model instance profile.save() registered = True # invalid forms, else: print user_form.errors, profile_form.errors # not a http post else: user_form = UserForm() profile_form = UserProfileForm() # Render the template depending on the context return render_to_response( 'account/register.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered}, context )
def signup_student(request): student_form = StudentForm(request.POST or None) user_form = UserForm(request.POST or None) if request.method == "POST": if student_form.is_valid() and user_form.is_valid(): user = user_form.save() student = student_form.save(commit=False) student.user = user student.save() return redirect("index") return render( request, "signup_student.html", {"form": user_form, "student_form": student_form, "grades": GRADE_CHOICES} )
def register(request): registered = False if request.method == 'POST': form = UserForm(data=request.POST) if form.is_valid(): user = form.save() user.set_password(user.password) user.save() registered = True messages.success(request, "Thank you for registering.") return redirect('login') else: form.errors else: form = UserForm() return render(request, 'accounts/register.html', {'form': form})
def register(request): if request.method == 'GET': user_form = UserForm() return render(request, 'accounts/login.html', {'user_form': user_form, }) elif 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() login_view(request) return HttpResponseRedirect(reverse_lazy('accounts:select_type')) else: return render(request, 'accounts/login.html', {'user_form': user_form, })
def add(request): user_form = UserForm( data=request.POST or None ) if user_form.is_valid(): user_form.save(auth.get_user(request)) messages.success(request, u"Usuário salvo com sucesso.") return redirect('user_list') template_context = { 'user_form': user_form, } return render( request=request, template_name='add.html', dictionary=template_context )
def register(request): user = None if request.method == 'POST': form = UserForm(request.POST) if form.is_valid(): #https://github.com/realpython/book3-exercises/blob/7dce6dbf77c62124cb0ef6d909cdd1a1afdc88de/django_ecommerce/payments/views.py cd = form.cleaned_data try: with transaction.atomic(): user = User.create(cd['name'], cd['email'], cd['password']) user.save() except IntegrityError: form.addError(cd['email'] + ' is already a member') else: request.session['user'] = user.pk return HttpResponseRedirect('/') #user = User( #name=form.cleaned_data['name'], # email=form.cleaned_data['email'], #) #ensure encrpyted password #user.set_password(form.cleaned_data['password']) #try: # user.save() #except IntegrityError: # form.addError(user.email + ' is already a member') #else: # request.session['user'] = user.pk # return HttpResponseRedirect('/') else: form = UserForm() return render_to_response( 'accounts/register.html', { 'form': form, 'user': user, }, context_instance=RequestContext(request) )