def post(self, request): form = UserForm(request.POST, request.FILES, instance=request.user) data = {"form": form} if form.is_valid(): form.save() return redirect(reverse("users:edit")) return render(request, self.template_name, data)
def update(request, id): employee = UserModel.objects.get(uid=id) form = UserForm(request.POST, instance=employee) if form.is_valid(): form.save() return redirect("/show") return Response(status=status.HTTP_200_OK)
def settings(request): usr = request.user form = UserForm(instance=usr) try: pno = usr.contactdetails # print(pno, usr.contactdetails) pform = UpdatePhoneNo(instance=pno) except: pno = None pform = UpdatePhoneNo() if request.method == 'POST': pform = UpdatePhoneNo(data=request.POST, instance=pno) form = UserForm(data=request.POST, instance=usr) if pform.is_valid(): p_obj = pform.save(commit=False) p_obj.user = request.user p_obj.save() if form.is_valid(): form.save() return render(request, 'users/settings.html', locals()) else: return render(request, 'users/settings.html', locals())
class UserProfileSettings(TemplateView, CategoryListMixin): template_name, form, cities, citys = None, None, None, None def get(self, request, *args, **kwargs): self.template_name = get_my_template("profile/settings/profile.html", request.user, request.META['HTTP_USER_AGENT']) if request.user.city: self.citys = request.user.city.region.get_cities() return super(UserProfileSettings, self).get(request, *args, **kwargs) def get_context_data(self, **kwargs): from users.forms import UserForm from region.models import Region context = super(UserProfileSettings, self).get_context_data(**kwargs) context["form"] = UserForm() context["regions"] = Region.objects.exclude(name="Все регионы", is_deleted=True) context["citys"] = self.citys return context def post(self, request, *args, **kwargs): from users.forms import UserForm self.form = UserForm(request.POST, request.FILES, instance=request.user) if request.is_ajax() and self.form.is_valid(): self.form.save() photo_input = request.FILES.get('s_avatar') if photo_input: request.user.create_s_avatar(photo_input) return HttpResponse() return super(UserProfileSettings, self).post(request, *args, **kwargs)
def user_login(request): post = request.POST.copy() if request.method == 'POST': post['username'] = post['username'].lower() email = post['username'] first_name = post['first_name'] form = UserForm(post) user_profile_form = UserProfileForm(post) if email and first_name: try: user = User.objects.get(email=email) except User.DoesNotExist: if form.is_valid(): user = form.save(commit=False) user.set_password(user.username) user = form.save() user = authenticate(username=email, password=email) if user is not None: if user.is_active: login(request, user) # FIXME post['user'] = user.id user_profile_form = UserProfileForm(post) if user_profile_form.is_valid(): try: profile = user.get_profile() except: aux = UserProfile.objects profile, created = aux.get_or_create(user=user) newsletter = user_profile_form.clean()['newsletter'] profile.newsletter = newsletter profile.save() try: spectacle = Spectacle.objects.get(status=True) if spectacle.mode == SPECTACLE_MODE_EASY or \ spectacle.mode == SPECTACLE_MODE_RESET: url = spectacle.get_easy_show_url() else: url = spectacle.get_hard_show_url() return HttpResponseRedirect(url) except Spectacle.MultipleObjectsReturned: msg = '<h1>%s</h1>' % _('Spectacle not found') return HttpResponseNotFound(msg) else: form = UserForm() user_profile_form = UserProfileForm() c = { 'form':form, 'user_profile_form':user_profile_form } return render(request, 'login.html', c)
def register(request): if request.method == 'POST': form = UserForm(request.POST) if form.is_valid(): form.save() else: form = UserForm() return render(request, 'users/register.html', context={'form': form})
def post(self, request): form = UserForm(request.POST) if form.is_valid(): form.save() username = form.cleaned_data.get('username') raw_password = form.cleaned_data.get('password1') user = authenticate(username=username, password=raw_password) login(request, user) return redirect('home') context = {'form': form} return render(request, 'users/new_user.html', context)
def profile(request): form = UserForm(request.POST or None, request.FILES or None, instance=request.user) args = {} args['form'] = form args['article'] = Article.objects.all() if request.method == 'POST': if form.is_valid(): form.save() return redirect('users:profile') return render(request, 'profile.html', args)
def edit_profile(request): user = request.user if request.method == 'POST': form = UserForm(request.POST, instance=user) if form.is_valid(): form.save() return redirect(reverse('profile')) form = UserForm(instance=user) context = {'form': form} return render(request, 'polls/edit_profile.html', context)
def test_user_form(self): """Test the combined User and BucketUser form""" form = UserForm(instance=self.user) self.assertEqual(type(form.bucket_user_form), BucketUserForm) data = {'first_name': 'Foo', 'last_name': 'Bar', 'bio': 'about me'} form = UserForm(data=data, instance=self.user) self.assertTrue(form.is_valid()) form.save() self.assertEqual(self.user.first_name, 'Foo') self.assertEqual(self.user.last_name, 'Bar') bucket_user = BucketUser.objects.get(user=self.user) self.assertEqual(bucket_user.bio, 'about me')
def user_edit(request, pk): user = User.get(pk) form = UserForm(request.POST or None, instance=user) profile = ProfileForm(request.POST or None, instance=get_profile(user)) if form.is_valid() and profile.is_valid(): form.save() profile.save() return HttpResponseRedirect(reverse("user-list")) return direct_to_template(request, "user_edit.html", extra_context={ "form": form, "profile": profile, "nav": {"selected": "users",}, })
def emp(request): if request.method == "POST": form = UserForm(json.loads(request.body)) #json handling for POST if form.is_valid(): try: form.save() return HttpResponse("OK") except: pass else: return HttpResponse("Form inValid") else: form = UserForm() return form
def registration(request): form = None if request.method == "POST": form = UserForm(request.POST) if form.is_valid(): form.save() return redirect(reverse_lazy('user_profile')) else: form = UserForm() return render(request, 'user/registration.html', {'form': form})
def test_user_form(self): """Test the combined User and SystersUser form""" form = UserForm(instance=self.user) self.assertEqual(type(form.systers_user_form), SystersUserForm) data = {'first_name': 'Foo', 'last_name': 'Bar', 'blog_url': 'http://example.com/'} form = UserForm(data=data, instance=self.user) self.assertTrue(form.is_valid()) form.save() self.assertEqual(self.user.first_name, 'Foo') self.assertEqual(self.user.last_name, 'Bar') systers_user = SystersUser.objects.get(user=self.user) self.assertEqual(systers_user.blog_url, 'http://example.com/')
def test_user_form(self): """Test the combined User and SystersUser form""" form = UserForm(instance=self.user) self.assertEqual(type(form.systers_user_form), SystersUserForm) data = {'first_name': 'Foo', 'last_name': 'Bar', 'blog_url': 'http://example.com/'} form = UserForm(data=data, instance=self.user) self.assertTrue(form.is_valid()) form.save() self.assertEqual(self.user.first_name, 'Foo') self.assertEqual(self.user.last_name, 'Bar') systers_user = SystersUser.objects.get() self.assertEqual(systers_user.blog_url, 'http://example.com/')
def users(request): form = UserForm() if request.method == 'POST': form = UserForm(request.POST) if form.is_valid(): form.save(commit=True) return HttpResponseRedirect(reverse("users")) users = User.objects.all() title = "This page contains an awesome list of users." context = {'users': users, 'form': form, 'page_title': title} return render(request, 'users/users.html', context=context)
def update_profile(request): if request.method == 'POST': user_form = UserForm(request.POST) profile_form = ProfileForm(request.POST) if user_form.is_valid() and profile_form.is_valid(): u = user_form.save() u.set_password(request.POST['password']) u.save() Profile.objects.get_or_create( user=u, position=request.POST.get('position'), phone=request.POST.get('phone'), address=request.POST.get('address'), birth_date=request.POST.get('birth_date'), joined_date=request.POST.get('joined_date'), image=request.FILES.get('image')) # profile_form.save() messages.success(request, ('Your profile was successfully updated!')) return redirect('core:main_dashboard') else: messages.error(request, ('Please correct the error below.')) else: user_form = UserForm() profile_form = ProfileForm() # user_form = UserForm(instance=request.user) # profile_form = ProfileForm(instance=request.user.profile) return render(request, 'core/register_new_member.html', { 'user_form': user_form, 'profile_form': profile_form })
def register(request): if request.method == 'POST': form = UserForm(request.POST) # print(form.errors.as_data()) if form.is_valid(): user = form.save(commit=False) user.is_active = False pwd = form.cleaned_data['password'] user.set_password(pwd) user.save() current_site = get_current_site(request) mail_subject = 'Activate your account.' message = render_to_string( 'users/activatemail.html', { 'user': user, 'domain': current_site.domain, 'uid': urlsafe_base64_encode(force_bytes(user.id)), 'token': account_activation_token.make_token(user), }) to_email = form.cleaned_data.get('email') email = EmailMessage(mail_subject, message, to=[to_email]) email.send() return HttpResponse( 'Please confirm your email address to complete the registration' ) else: form = UserForm() return render(request, 'users/registration.html', {'user_form': form})
def register_customer(request): registered = False if request.method == "POST": user_form = UserForm(data=request.POST) customer_form = CustomerForm(data=request.POST) if user_form.is_valid() and customer_form.is_valid(): user = user_form.save() user.set_password(user.password) user.save() customer = customer_form.save(commit=False) customer.user = user customer.save() registered = True else: print(user_form.errors, customer_form.errors) else: user_form = UserForm() customer_form = CustomerForm() return render( request, 'users/register_customer.html', { 'user_form': user_form, 'customer_form': customer_form, 'registered': registered })
def user_register(request): form = UserForm() if request.method == 'POST': f = UserForm(request.POST) #form.permissao = request.POST['permissao'] valido = False if f.is_valid(): valido = True u = f.save(commit=False) u.date_joined = datetime.date.today() # request.POST['permissao'] u.permissao = f.cleaned_data['permissao'] u.save() c = { 'form': form, } if valido: c['sucesso'] = True else: c['sucesso'] = False return render(request, 'users/register.html', c) # return redirect('user_login') c = { 'form': form, } return render(request, 'users/register.html', c)
def register(request): registed = False if request.method == "POST": user_form = UserForm(data=request.POST) custom_form = CustomUserForm(data=request.POST) if user_form.is_valid() and custom_form.is_valid(): user = user_form.save() user.save() custom = custom_form.save(commit=False) custom.user = user custom.save() registed = True return HttpResponseRedirect(reverse('login')) else: print(user_form.errors, custom_form.errors) else: user_form = UserForm() custom_form = CustomUserForm return render(request, 'users/register.html', { 'registed': registed, 'user_form': user_form, 'custom_form': custom_form })
def cadastro(request): if request.method == 'POST': form = UserForm(request.POST) form_perfil = PerfilForm(request.POST) print(form_perfil.is_valid()) if form.is_valid() and form_perfil.is_valid(): user = form.save() perfil = form_perfil.save(commit=False) perfil.user = user perfil.save() email = form.cleaned_data.get('username') password = form.cleaned_data.get('password1') user = authenticate(username=email, password=password) auth_login(request, user) return redirect('/') else: form = UserForm(request.POST) form_perfil = PerfilForm(request.POST) contexto = { 'form': form, 'form_perfil': form_perfil, } return render(request, 'cadastro.html', contexto)
def user_register(request): if request.method == "GET": user_form = UserForm() profile_form = ProfileForm() elif request.method == "POST": user_form = UserForm(request.POST) profile_form = ProfileForm(request.POST) if user_form.is_valid() and profile_form.is_valid(): user = user_form.save() profile = profile_form.save(commit=False) profile.user = user profile.save() password = user.password # The form doesn't know to call this special method on user. user.set_password(password) user.save() # You must call authenticate before login. :( user = authenticate(username=user.username, password=password) login(request, user) messages.add_message( request, messages.SUCCESS, "Congratulations, {}, on creating your new account! You are now logged in.".format( user.username)) return redirect('index') return render(request, "users/register.html", {'user_form': user_form, 'profile_form': profile_form})
def post(self, request, *args, **kwargs): user_form = UserForm(request.POST) user_profile_form = SignUpProfileForm(request.POST) if user_form.is_valid() and user_profile_form.is_valid(): user = user_form.save() user_profile = UserProfile( user = user, city = user_profile_form.data['city'], country = user_profile_form.data['country'] ) try: user_profile.save() user = authenticate( username=user_form.data.get('username'), password=user_form.data.get('password1') ) login(self.request, user) except: transaction.rollback() return HttpResponseRedirect(self.success_url) else: context = {} context['user_form'] = user_form context['user_profile_form'] = user_profile_form context['cities'] = City.objects.all() context['countries'] = Country.objects.all() return self.render_to_response(context)
def register_rater(request): if request.method == "POST": user_form = UserForm(request.POST) rater_form = RaterForm(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 rater.save() password = user.password user.set_password(password) user.save() user = authenticate(username=user.username, password=password) login(request, user) messages.add_message( request, messages.SUCCESS, "Welcome, {}. You have successfully created an account and are now logged in".format(user.username)) return redirect('top20') else: user_form = UserForm() rater_form = RaterForm() return render(request, "users/register.html", {'user_form': user_form, 'rater_form': rater_form})
def post(self, request): if request.GET.get('login'): self.post_login(request) username = request.POST.get('username') password = request.POST.get('password') user = authenticate(username=username, password=password) if user: if user.is_active: login(request, user) return redirect('tasks:index') return render(request, 'users/login.html', {'user_form': UserForm(), 'profile_form': ProfileForm()}) else: user_form = UserForm(data=request.POST) profile_form = ProfileForm(data=request.POST) if user_form.is_valid() and profile_form.is_valid(): with atomic(): user = user_form.save() user.set_password(user.password) user.save() profile = profile_form.save(commit=False) profile.user = user profile.creating = True profile.updating = True thread = Thread() thread.save() profile.thread = thread profile.save() login(request, user) return redirect('tasks:index') else: return render(request, 'users/login.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() profile = profile_form.save(commit=False) profile.user = user profile.save() password = user.password # The form doesn't know to call this special method on user. user.set_password(password) user.save() # You must call authenticate before login. :( user = authenticate(username=user.username, password=password) login(request, user) messages.add_message( request, messages.SUCCESS, "Congratulations, {}, on creating your new account! You are now logged in." .format(user.username)) return redirect('index') return render(request, "users/register.html", { 'user_form': user_form, 'profile_form': profile_form })
def Register(request): context = RequestContext(request) registered = False if request.method == 'POST': user_form = UserForm(request.POST) profile_form = UserProfileForm(request.POST) if user_form.is_valid() and profile_form.is_valid(): user = user_form.save() user.set_password(user.password) user.save() profile = profile_form.save(commit=False) profile.user = user if 'picture' in request.FILES: profile.picture = request.FILES['picture'] profile.save() registered = True login(request, user) return redirect('home') else: print user_form.errors, profile_form.errors else: user_form = UserForm() profile_form = UserProfileForm() return render(request, 'users/register.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered})
def post(self, request): user_form = UserForm(request.POST) profile_form = ProfileForm(request.POST) if user_form.is_valid() and profile_form.is_valid(): user = user_form.save() profile = profile_form.save(commit=False) profile.user = user profile.save() password = user.password user.set_password(password) user.save() user = authenticate(username=user.username, password=password) login(self.request, user) messages.add_message( request, messages.SUCCESS, "Account Successfully Created.") return redirect("/") else: return render(request, "users/register.html", {"form1": user_form, "form2": profile_form})
def accept_invite(request, token): invite = get_object_or_404(Invite, token=token) if not invite.is_tokened: invite.is_tokened = True invite.save() user = User.objects.filter(email=invite.email) if user.exists(): _create_event_member(user[0], invite.event) login(request, user[0]) return redirect('post_details', invite.event.id) else: form = UserForm() if request.method == 'POST': form = UserForm(request.POST) if form.is_valid(): password = form.cleaned_data['password'] email = form.cleaned_data['email'] member = form.save() _create_event_member(member, invite.event) user = authenticate(email=email, password=password) if user is not None: login(request, user) return redirect('post_details', invite.event.id) return render(request, 'users/signup.html', {'form': form}) else: raise Http404("Token does not exist")
def register(request): activate(request.LANGUAGE_CODE) if not isinstance(request.user, models.AnonymousUser): logout(request) if request.method == 'POST': user_form = UserForm(data=request.POST) profile_form = UserExtendedForm(data=request.POST) user_tz = request.POST.get('timezone') if user_form.is_valid() and profile_form.is_valid(): user = user_form.save() user.set_password(user.password) profile = profile_form.save(commit=False) profile.user = user if user_tz: profile.timezone = user_tz try: profile.save() except: raise ValidationError("Can't save user to the database!") user.save() return HttpResponseRedirect(reverse('users:login')) else: user_form = UserForm() profile_form = UserExtendedForm() return render( request, 'users/register.html', { 'user_form': user_form, 'profile_form': profile_form, 'timezones': pytz.common_timezones, 'def_timezone': settings.DEF_USER['timezone'] })
def register(request): """ Register a new user """ # Set registered to false by default registered = False if request.method != 'POST': # This SHOULD always be post form = UserForm() account_form = UserAccountForm() else: form = UserForm(data=request.POST) account_form = UserAccountForm(data=request.POST) if form.is_valid() and account_form.is_valid(): new_user = form.save() new_user.set_password(new_user.password) new_user.save() account = account_form.save(commit=False) account.user = new_user account.save() registered = True login(request, new_user) return redirect('book_keeping:index') else: print(form.errors, account_form.errors) context = { 'form': form, 'account_form': account_form, 'registered': registered } return render(request, 'users/register.html', context)
def _update(request, user): was_superuser = user.is_superuser form = UserForm(instance = user, data = request.PUT) if form.is_valid(): user = form.save() # Check if modified user is the last superuser in which case # his super-user status must remain True if was_superuser \ and not user.is_superuser \ and not User.objects.filter(is_superuser = True): message = INFO_MSG%"Au moins un utilisateur doit être super-utilisateur." request.user.message_set.create( message = message ) user.is_superuser = True user.save() # Changes have been made. message = SUCCESS_MSG % "Modification effectuée avec succès." request.user.message_set.create( message = message ) if request.user.is_superuser: return redirect( 'user_collection' ) else: return redirect( 'user_edit', request.user.id ) else: message = ERROR_MSG % 'Le formulaire est invalide, veuillez corriger les erreurs suivantes.' request.user.message_set.create( message = message ) return direct_to_template(request, "users/edit.html", { 'user': user, 'form': form })
def register(request): Context = RequestContext(request) if request.method == 'POST': #user bilgilerini girmis kayit ol butonuna basmis. 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() #registered = True profile = profile_form.save(commit = False) profile.user = user if 'picture' in request.FILES: profile.picture = request.FILES['picture'] profile.save() return render(request, 'users/register_success.html') else: print user_form.errors, profile_form.errors else: # henuz yeni register ekrani goren user icin user_form = UserForm() profile_form = UserProfileForm() return render_to_response( 'users/registration.html', {'user_form':user_form, 'profile_form':profile_form}, Context)
def register(request): form = UserForm(request.POST or None) if form.is_valid(): instance = form.save(commit=False) instance.save() context = {'form': form} return render(request, 'index.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.save() profile = profile_form.save(commit= False) profile.user = user profile.save() registered = True else: print(user_form.errors,profile_form.errors) else: user_form =UserForm() profile_form = UserProfileInfoForm() context ={ 'registered': registered, 'user_form': user_form, 'profile_form': profile_form, } return render(request, 'users/registration.html', context)
def SignUp(request): registered = False if request.method == 'POST': user_form = UserForm(data=request.POST) profile_form = UserProfileInfoForm(data=request.POST) if user_form.is_valid() and profile_form.is_valid(): user = user_form.save() user.set_password(user.password) user.save() profile = profile_form.save(commit=False) profile.user = user if 'profile_pic' in request.FILES: profile.profile_pic = request.FILES['profile_pic'] profile.save() registered=True else: print(user_form.errors, profile_form.errors) else: user_form = UserForm() profile_form = UserProfileInfoForm() return render(request, 'signup.html',{'user_form':user_form,'profile_form':profile_form, 'registered':registered})
def create(self, request, *args, **kwargs): registered = False flag =1 user_form = UserForm(data=request.POST) profile_form = UserProfileForm(data=request.POST) User = get_user_model() if user_form.is_valid() and profile_form.is_valid(): for User in User.objects.filter(): if user_form.cleaned_data['email'] == User.email: flag =0 user_form.cleaned_data['username'] = "******" print("This mail address already exists!") if flag ==1: user = user_form.save() print("user saved") 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("not-saved") else: print(user_form.errors,profile_form.errors) return render(request,'users/registration.html', {'user_form':user_form, 'profile_form':profile_form, 'registered':registered, 'flag':flag})
def register(request): registered = False if request.method == 'POST': user_form = UserForm(data=request.POST) if user_form.is_valid(): user = user_form.save() user.set_password(user.password) user.save() registered = True return render(request, 'login.html', {}) else: print(user_form.errors) else: user_form = UserForm() # Render the template depending on the context. return render(request, 'register.html', { 'user_form': user_form, 'registered': registered })
def register(request): res = create_exception( request, __name__, exception="unknown request method") if request.method == "POST": form = UserForm(request.POST) if form.is_valid(): user_obj = form.save() user_obj.first_name = user_obj.first_name.capitalize() user_obj.last_name = user_obj.last_name.capitalize() username = user_obj.first_name.lower( )[0] + user_obj.last_name.lower() + str(randint(1, 10000)) user_obj.username = username user_details_obj = Personal_Info(username=username, date_of_birth=form.cleaned_data['date_of_birth'], pin_code=form.cleaned_data['pin_code'], address=form.cleaned_data['address'], city=form.cleaned_data['city'], email_verified=False) try: user_obj.save() user_details_obj.save() print("{} : {} {} added".format( username, user_obj.first_name, user_obj.last_name)) except Exception as e: print(e) res = create_exception(request, __name__, exception=e) else: res = redirect('dashboard') else: res = create_exception(request, __name__, str( ValueError("form data in request not valid"))) elif request.method == "GET": empty_form = UserForm() res = render(request, "users/register.html", {"form": empty_form, "helper": empty_form.get_helper()}) return res
def signup(request): form=UserForm(request.POST or None) if form.is_valid(): save_it=form.save(commit=False) save_it.save() messages.success(request,'Thank you for Joining us') return HttpResponseRedirect('/signup/') return render_to_response("signup.html",locals(),context_instance=RequestContext(request))
def user_edit(request, pk): user = User.get(pk) form = UserForm(request.POST or None, instance=user) profile = ProfileForm(request.POST or None, instance=get_profile(user)) if form.is_valid() and profile.is_valid(): form.save() profile.save() return HttpResponseRedirect(reverse("user-list")) return direct_to_template(request, "user_edit.html", extra_context={ "form": form, "profile": profile, "nav": { "selected": "users", }, })
def register(request): context = RequestContext(request) # Set boolean to false registered = False # if request is post if request.method == 'POST': # Initialize forms to collect user data user_form = UserForm(data=request.POST) profile_form = UserProfileForm(data=request.POST) # create user and userprofile classes to add data 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 # retrieve profile registration information if 'first name' in request.FILES: profile.fistName = request.FILES['first name'] if 'last name' in request.FILES: profile.lastName = request.FILES['last name'] if 'picture' in request.FILES: profile.picture = request.FILES['picture'] if 'school' in request.FILES: profile.school = request.FILES['school'] if 'are you a teacher?' in request.FILES: profile.isTeacher = request.FILES['are you a teacher?'] profile.save() registered = True # logs you in if your registration details check out user = authenticate(username=request.POST['username'], password=request.POST['password']) login(request, user) return HttpResponseRedirect('/forum/') else: print user_form.errors, profile_form.errors # if request is not post else: user_form = UserForm() profile_form = UserProfileForm() return render_to_response( 'users/register.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered}, context)
def registration(request): 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. # 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. user = user_form.save(commit=False) # Now we hash the password with the set_password method. user.set_password(user.password) profile = profile_form.save(commit=False) # 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 'avatar' in request.FILES: profile.avatar = request.FILES['avatar'] # Now we save the UserProfile and User model instance. user.save() profile.user = user profile.save() # Update our variable to tell the template registration was successful. messages.success(request, _('Registration successful, you can log in.')) return HttpResponseRedirect(reverse('users:login')) # 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( 'users/registration.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered}, context)
def user_edit(request): if request.method == 'POST': form = UserForm(request.POST, instance=request.user) if form.is_valid(): form.save() messages.add_message(request, messages.SUCCESS, _("Your data has been successfully saved.")) return redirect('home') else: form = UserForm(instance=request.user) context = { 'cancel_url': reverse('user_profile'), 'form': form, } return render_to_response('accounts/edit.jade', context, context_instance=RequestContext(request))
def user_edit(request, pk): form = UserForm(request.POST or None, instance=User.get(pk)) if form.is_valid(): obj = form.save(commit=False) obj.save() return HttpResponseRedirect(reverse("user-list")) return direct_to_template(request, "user_edit.html", extra_context={ "form": form, "nav": {"selected": "users",}, })
def edit_profile(request, username): user = get_object_or_404(User, username=username) profile = user.get_profile() if request.user.pk != user.pk and request.user.has_perm("user.can_change") == False: return HttpResponseNotAllowed("You cannot edit this profile.") if request.method == "POST": this_user_form = UserForm(request.POST, instance=user) if this_user_form.is_valid(): this_user_form.save() return redirect(profile) else: this_user_form = UserForm(instance=user) return render_to_response( "users/edit-profile.html", {"this_user": user, "this_user_form": this_user_form}, context_instance=RequestContext(request), )
def post(self, request): uform = UserForm(data=request.POST) if uform.is_valid(): user = uform.save() user.set_password(user.password) user.save() self.registered = True else: print uform.errors context = self.get_context_data() context['registered'] = self.registered return render(request, self.template_name, context)
def register(request): # Initial value set to False. Code changes value to True when registration succeeds. registered = False if request.method == 'POST': # Get form information. user_form = UserForm(data=request.POST) profile_form = UserProfileForm(data=request.POST) picture_form = PictureForm(data=request.POST) # If the 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 with the set_password method. user.set_password(user.password) user.save() # Sort out the UserProfile instance. profile = profile_form.save(commit=False) image = picture_form.save(commit=False) profile.user_extended = user image.user = user # User provides a photo if 'file' in request.FILES: image.file = request.FILES['file'] # Save the UserProfile model instance. profile.save() image.save() # Update our variable to tell the template registration was successful. registered = True return HttpResponseRedirect('/login/') # Print problems to the terminal, show to the user. else: print(user_form.errors, profile_form.errors) # Blank forms, ready for user input. else: user_form = UserForm() profile_form = UserProfileForm() picture_form = PictureForm() # Render the template depending on the context. return render(request, 'register.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered, 'picture_form': picture_form} )
def register(request): #Get the request context context = RequestContext(request) #Registration success/failure boolean registered = False #If HTTP POST, process form if request.method == 'POST': #Grab raw data from 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() #Hash the password and update the user object user.set_password(user.password) user.save() #Save UserProfile data profile = profile_form.save(commit=False) profile.user = user #Did the user provide a profile image if 'profile_image' in request.FILES: profile.profile_image = request.FILES['profile_image'] #Save the UserProfile model instance profile.save() #Set registration boolean to true registered = True #Invalid forms? else: print(user_form.errors, profile_form.errors) #Not a HTTP POST? Render blank forms else: user_form = UserForm() profile_form = UserProfileForm() #Render the template return render_to_response( 'users/register.html', {'user_form': user_form, 'profile_form': profile_form, 'registered':registered}, context)
def profile(request, slug): try: user = User.objects.get(slug=slug) except: raise Http404 if request.user == user: # own profile if request.method == "POST": # if the form as been submitted form = UserForm(request.POST, instance=request.user) if form.is_valid(): form.save() url = reverse("user", kwargs={"slug": request.user.slug}) return HttpResponseRedirect(url) else: for field, error in form.errors.items(): messages.add_message(request, messages.ERROR, error) return render(request, "own_profile.html", {"profile": user, "form": form}) form = UserForm(instance=request.user) return render(request, "own_profile.html", {'profile': user, 'form': form}) elif user.hasProfile: # another's (public) profile return render(request, "profile.html", {'profile': user}) else: return render(request, "no_profile.html", {"profile": user})
def signup(request): template = 'users/signup.html' context_instance = RequestContext(request) if request.method == 'POST': form = UserForm(request.POST) if form.is_valid(): new_user = form.save(commit=False) #Encript password before save it in the DB new_user.password = make(new_user.password) new_user.save() return HttpResponseRedirect('/users/login/') else: form = UserForm() return render_to_response(template, {'form': form}, context_instance)
def register(request): if request.method == "POST": user_form = UserForm(request.POST) if user_form.is_valid(): user = user_form.save() password = make_password(request.POST['password']) user.password = password user.save() profile = UserProfile() profile.user = user api_key = hashlib.md5((user.username + str(datetime.now())).encode('utf-8')).hexdigest() profile.api_key = api_key print("*"*20) print(api_key) profile.save() return redirect('user_home', username=user) return HttpResponse("Couldn't register this user")
def register(request): # init vars register_failure = [] registered = False if request.method == 'POST': # get main user form user_form = UserForm(data=request.POST) # get user profile form profile_form = UserProfileForm(data=request.POST) if user_form.is_valid() and profile_form.is_valid(): # save main user details user = user_form.save() user.set_password(user.password) user.save() # use the user details and save profile form profile = profile_form.save(commit=False) profile.user = user profile.save() # use the user details and create oauth new_oauth = Oauth(user=user) new_oauth.save() # login the new user user_login = auth.authenticate(username=request.POST.get('username'),password=request.POST.get('password')) loggedin = auth.login(request, user_login) if loggedin: registered = True else: print user_form.errors, profile_form.errors else: user_form = UserForm() profile_form = UserProfileForm() return render(request, 'users/register.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered})
def edit(request, pk): """Edit or create an user""" try: object = User.objects.get(pk=pk) except: object = User() if request.method == 'POST': # If the form has been submitted... form = UserForm(request.POST, instance=object) if form.is_valid(): # If the form is valid object = form.save() messages.success(request, _('The user has been saved.')) return redirect('users.views.list') else: form = UserForm(instance=object) return render(request, 'users/users/edit.html', {'form': form})
def edit_perfil(request): perfil = Perfil.objects.get(usuario = request.user) if request.method == 'POST': formperfil = PerfilEditForm(request.POST, request.FILES, instance=perfil) formuser = UserForm(request.POST, instance=request.user) if formuser.is_valid() and formperfil.is_valid(): p = formperfil.save() u = formuser.save() p.user = request.user p.save() msm = "Perfil Completado Correctamente" messages.add_message(request, messages.INFO, msm) return HttpResponseRedirect(reverse(index_perfil)) else: formperfil = PerfilEditForm(instance=perfil) formuser = UserForm(instance=request.user) return render(request, 'users/edit_perfil.html', { 'formperfil':formperfil, 'formuser':formuser, 'perfil':perfil, })
def New(request): template_file = "user-new.html" context = RequestContext(request) form = UserForm(request.POST or None, request.FILES or None) if form.is_valid(): mymodel = form.save() msg = u"User successfully created" messages.add_message(request, messages.SUCCESS, msg) return redirect("users:home") params = { 'form': form, } return render_to_response ( template_file, params, context_instance = context )
def register(request): 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() # Login and redirect to root url user = auth.authenticate( username=request.POST['username'], password=request.POST['password']) auth.login(request, user) return HttpResponseRedirect('/') else: user_form = UserForm() return render( request, 'users/register.html', { 'form': user_form, })
def Edit(request,user_id): template_file = "user-edit.html" context = RequestContext(request) obj = User.objects.get(pk=user_id) form = UserForm(request.POST or None, request.FILES or None,instance=obj) if form.is_valid(): mymodel = form.save() msg = u"User saved successfully" messages.add_message(request, messages.SUCCESS, msg) return redirect("users:home") params = { 'form': form, 'user_id': user_id, } return render_to_response ( template_file, params, context_instance = context )
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) restaurant_boolean = find_restaurant(context, profile.address, profile.city, profile.state) if restaurant_boolean[0] == True: profile.restaurant = restaurant_boolean[1] else: return HttpResponse("Unfortunately, we are not currently serving your area. Please try again soon.") profile.user = user print profile.address # Now we save the UserProfile model instance. profile.save() r0 = randint(0, 9) r1 = randint(0, 9) r2 = randint(0, 9) r3 = randint(0, 9) str_sec = str(r0)+str(r1)+str(r2)+str(r3) account_sid = "ACd2d6a002416aad11df6d7b3d529506b2" auth_token = "616085bee1e2c14db70339a86bfa9dda" client = TwilioRestClient(account_sid, auth_token) message = client.sms.messages.create(body=user.first_name + ", thanks for signing up for Dormserv! Your code is " + str_sec, to= profile.phone, from_="+19146185355") # Replace with your Twilio number registered = True return render_to_response('confirm_account.html', {'profile': profile.id, 'user':profile.user.id, 'str_sec':str_sec}, context) # 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)