def get(self): chtml = captcha.displayhtml( public_key="6LcfNesSAAAAALpz578J4CXiHk3hwgPZIWSAvtVe", use_ssl=False, error=None) template_values = {'captchahtml': chtml} #self.response.write(template_values) self.response.write(""" <html> <h1> Go Bromius Image Sharer </h1> </br> <p> Share an image! </p> <form name="post_image_form" action="post_image" method="post" enctype="multipart/form-data"> File name:<input type="file" name="imgfile"> <br> """) self.response.write(chtml) self.response.write(""" <input type="submit" value="Submit"</br> </form> </html> """)
def get(self): chtml = captcha.displayhtml( public_key = "6LcfNesSAAAAALpz578J4CXiHk3hwgPZIWSAvtVe", use_ssl = False, error = None) template_values = { 'captchahtml': chtml } #self.response.write(template_values) self.response.write(""" <html> <h1> Go Bromius Image Sharer </h1> </br> <p> Share an image! </p> <form name="post_image_form" action="post_image" method="post" enctype="multipart/form-data"> File name:<input type="file" name="imgfile"> <br> """) self.response.write(chtml) self.response.write(""" <input type="submit" value="Submit"</br> </form> </html> """)
def do(request): WZ = Z.SetWhoZwho(request) if request.method == 'POST': # If the form has been submitted... form = ForgotLoginForm(request.POST) # A form bound to the POST data if form.is_valid(): # All validation rules pass check_captcha = captcha.submit (form.cleaned_data['recaptcha_challenge_field'], form.cleaned_data['recaptcha_response_field'], WZ['CaptchaPrivate'], "127.0.0.1") if not check_captcha.is_valid: WZ['ErrorMessage'] = "[FL01]: Captcha response was incorrect." else: users = User.objects.all(). \ filter(first_name__exact=form.cleaned_data['first_name']). \ filter(last_name__exact=form.cleaned_data['last_name']). \ filter(email__exact=form.cleaned_data['email']) if len(users) == 1: send_mail( 'Forgotten login ID.', 'Login ID: ' + users[0].username, WZ['AdminEmail'], [users[0].email], fail_silently=False) WZ['ErrorMessage'] = "[FL02]: Login ID sent to your email." else: WZ['ErrorMessage'] = "[FL03]: Invalid Login ID." else: WZ['ErrorMessage'] = str(form.errors) else: form = ForgotLoginForm() captcha_html = captcha.displayhtml(WZ['CaptchaPublic'], use_ssl = True) c = { 'form': form, 'WZ': WZ, 'captcha_html': captcha_html } c.update(csrf(request)) return render_to_response('UserForgotLogin.html', c )
def renderInPage(self): """ Render comments form in page context. """ _ = self.macro.request.getText html = u'''<div class="comments_form"> <form method="POST" action="%(page_uri)s"> <input type="hidden" name="do" value="comment_add"> ''' % { 'page_uri': self.macro.request.request.url } if self.msg: html += u'<div id="comment_message">' html += u'<p>%s</p>' % self.msg html += u'</div>' if self.errors: html += u'<div id="comment_error">' if len(self.errors) > 1: html += u'<p>%s</p><ul>' % _('Your comment has errors:') else: html += u'<p>%s</p><ul>' % _('Your comment has one error:') for error in self.errors: html += u'<li>%s</li>' % error html += u'</div>' html += ''' <ul> <li> <span class="name">%(name_label)s</span> <input type="text" id="name" maxlength=128 name="user_name" value="%(user_name)s" size=8> <span class="comment_body">%(comment_label)s</span> <input type="text" name="comment" value="%(comment)s" size=64> ''' % { 'name_label': u'名前: ', 'comment_label': u'コメント: ', 'page_name': self.page_name, 'user_name': self.comment['user_name'], 'comment': self.comment['comment'],} if get_cfg(self.macro, 'comment_recaptcha', False) and not self.passpartout: import captcha html += u""" <tr> <th>%(recaptcha_label)s</th> <td>%(recaptcha)s</td> </tr>""" % { 'recaptcha' : captcha.displayhtml( get_cfg(self.macro, 'comment_recaptcha_public_key')), 'recaptcha_label': _('Are you human?') } html += """ <input type="submit" value="%(label)s"> </form></div>""" % { 'label': _('Send comment') } try: return self.macro.formatter.rawHTML(html) except: return self.macro.formatter.escapedText('')
def show_index(self, params={}, c_error=None): path = os.path.join(os.path.dirname(__file__), 'templates/index.html') params['chtml'] = captcha.displayhtml( public_key = RECAPTCHA_PUBLIC, use_ssl = False, error = c_error) self.response.out.write(template.render(path, params))
def now(request): WZ = Z.SetWhoZwho(request) if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): check_captcha = captcha.submit (form.cleaned_data['recaptcha_challenge_field'], form.cleaned_data['recaptcha_response_field'], WZ['CaptchaPrivate'], "127.0.0.1") if not check_captcha.is_valid: WZ['ErrorMessage'] = "[UR01]: Captcha response was incorrect." else: users = User.objects.all().filter(username__exact=form.cleaned_data['login_id']) if len(users) < 1: new_user = User() new_user.username = form.cleaned_data['login_id'] new_user.first_name = form.cleaned_data['first_name'] new_user.last_name = form.cleaned_data['last_name'] new_user.email = form.cleaned_data['email'] new_user.set_password(form.cleaned_data['password']) new_user.save() new_name = Name() new_name.preferred = form.cleaned_data['first_name'] new_name.first = form.cleaned_data['first_name'] new_name.last = form.cleaned_data['last_name'] new_name.authority = Z.NewRW new_name.user = new_user new_name.save() new_name.owner = new_name.id new_name.save() auth_user = authenticate(username=new_user, password=form.cleaned_data['password']) if auth_user is not None: if auth_user.is_active: login(request, auth_user) WZ['Authenticated'] = 1 request.session['last_time'] = time() WZ = Z.SetWhoZwho(request, '.') return HttpResponseRedirect('/WhoZwho/' + WZ['Tabs'][WZ['ActiveTab']][3]) else: WZ['ErrorMessage'] = "[UR02]: Login ID disabled." else: WZ['ErrorMessage'] = "[UR03]: Login ID is invalid." else: WZ['ErrorMessage'] = "[UR04]: The selected Login ID is already in use." else: WZ['ErrorMessage'] = str(form.errors) else: form = RegistrationForm() # An unbound form captcha_html = captcha.displayhtml(WZ['CaptchaPublic'], use_ssl = True) c = { 'form': form, 'WZ': WZ, 'captcha_html': captcha_html } c.update(csrf(request)) return render_to_response('UserRegistration.html', c )
def free_comment_wrapper(request, extra_context={}, context_processors=None): if request.POST: check_captcha = captcha.submit( request.POST.get("recaptcha_challenge_field", ""), request.POST.get("recaptcha_response_field", ""), settings.RECAPTCHA_PRIVATE_KEY, request.META["REMOTE_ADDR"], ) if check_captcha.is_valid is False: raise Http404, "Invalid Captcha Attempt" extra_context["recaptcha_html"] = captcha.displayhtml(settings.RECAPTCHA_PUB_KEY) return post_free_comment(request, extra_context, context_processors) raise Http404, "Only POSTs are allowed"
def do(request): WZ = Z.SetWhoZwho(request) if WZ["ErrorMessage"]: return GoLogout(request, WZ) if request.method == "POST": # If the form has been submitted... form = UserChangePasswordForm(request.POST, request.FILES) if form.is_valid(): # All validation rules pass check_captcha = captcha.submit( form.cleaned_data["recaptcha_challenge_field"], form.cleaned_data["recaptcha_response_field"], WZ["CaptchaPrivate"], "127.0.0.1", ) if not check_captcha.is_valid: WZ["ErrorMessage"] = "[CP01]: Captcha response was incorrect." else: try: user = User.objects.get(username__exact=WZ["User"]) except: return GoLogout(request, WZ, "[CP02]: Password change disabled.") user.set_password(form.cleaned_data["password"]) user.save() user.name.password_timeout = None user.name.save() auth_user = authenticate(username=WZ["User"], password=form.cleaned_data["password"]) if auth_user is not None: if auth_user.is_active: login(request, auth_user) WZ["Authenticated"] = 1 request.session["last_time"] = time() WZ = Z.SetWhoZwho(request, ".") return HttpResponseRedirect("/WhoZwho/" + WZ["Tabs"][WZ["ActiveTab"]][3]) else: WZ["ErrorMessage"] = "[CP03]: Login ID disabled." else: WZ["ErrorMessage"] = "[CP04]: Login ID disabled." else: WZ["ErrorMessage"] = str(form.errors) else: form = UserChangePasswordForm() captcha_html = captcha.displayhtml(WZ["CaptchaPublic"], use_ssl=True) context = {"captcha_html": captcha_html, "form": form, "WZ": WZ} context.update(csrf(request)) return render_to_response("UserChangePassword.html", context)
def get(self): chtml = captcha.displayhtml( public_key = recaptcha_public_key, use_ssl = False, error = None) # Set the template parameters to pass back to the template. template_values = { 'categories': categories(), 'captchahtml': chtml } path = os.path.join(os.path.dirname(__file__), 'index.html') self.response.out.write(template.render(path, template_values))
def signup(request): import captcha email = "" key = request.REQUEST.get("key", "") pu = None if key: try: pu = PseudoUser.objects.get(pk=key) email = pu.email except: key = "" if request.method == "POST": form = SignUpForm(request.POST) check_captcha = captcha.submit( request.POST["recaptcha_challenge_field"], request.POST["recaptcha_response_field"], settings.RECAPTCHA_PRIVATE_KEY, request.META["REMOTE_ADDR"], ) if check_captcha.is_valid and form.is_valid(): first_name = form.cleaned_data["first_name"] last_name = form.cleaned_data["last_name"] email = form.cleaned_data["email"] username = form.cleaned_data["username"] password = form.cleaned_data["password"] create_account(first_name, last_name, username, email, password) user = authenticate(username=username, password=password) login(request, user) if pu: from auxiliary import base36_to_int hc_id, t = pu.host_class_to.split(",") hc = HostClass.objects.get(pk=base36_to_int(hc_id)) hcm = HostClassMember(host_class=hc, user=user) hcm.save() return HttpResponseRedirect("/h/v/" + hc.pk) else: return HttpResponseRedirect("/accounts/edit/") else: form = SignUpForm({"email": email}) html_captcha = captcha.displayhtml(settings.RECAPTCHA_PUBLIC_KEY, use_ssl=True) return render_to_response( "accounts/signup.html", {"form": form, "key": key, "html_captcha": html_captcha}, context_instance=RequestContext(request), )
def get(self): greetings="parametro" chtml = captcha.displayhtml( public_key = "6LfAO78SAAAAAHsj8mGWXKvrG8QWxMBWznhLZxTe", use_ssl = False, error = None) template_values = { 'greetings': greetings, 'captchahtml': chtml, } path = os.path.join(os.path.dirname(__file__), 'templates/index.html') self.response.out.write(template.render(path, template_values))
def signup(request, template_name='registration/register.html'): captcha_form = captcha.displayhtml("6LfitQAAAAAAAPuPkbRUUbT6mjhFbTGaS_nwKjkl") if request.method == 'POST': recaptcha_challenge_field = request.POST["recaptcha_challenge_field"] recaptcha_response_field = request.POST["recaptcha_response_field"] private_key = "6LfitQAAAAAAAGlpZA4DyouLEWRkfqLwBawQAxrq" remoteip = request.META['REMOTE_ADDR'] captcha_response = captcha.submit(recaptcha_challenge_field=recaptcha_challenge_field, recaptcha_response_field=recaptcha_response_field, private_key=private_key, remoteip=remoteip) if captcha_response.is_valid: new_data = request.POST form = UserForm(data=new_data) if form.is_valid(): new_user = form.save() profile = Profile(user=new_user, first_name=new_data['first_name'], last_name=new_data['last_name'], email=new_data['email'], country='us') profile.save() login(request, authenticate(username=new_data['username'], password=new_data['password2'])) # Why doesn't this work? AttributeError: 'User' object has no attribute 'backend' #login(request, new_user) return HttpResponseRedirect("/accounts/profile/") else: form = UserForm(request.POST) captcha_error = "<span style='color:red'>Incorrect captcha, please try again!</span>" else: form = UserForm() captcha_error = "" return render_to_response(template_name, dict(form=form, captcha_form=captcha_form, captcha_error=captcha_error), context_instance=RequestContext(request))
def do(request): WZ = Z.SetWhoZwho(request) if request.method == 'POST': # If the form has been submitted... form = ForgotPasswordForm(request.POST) # A form bound to the POST data if form.is_valid(): # All validation rules pass check_captcha = captcha.submit (form.cleaned_data['recaptcha_challenge_field'], form.cleaned_data['recaptcha_response_field'], WZ['CaptchaPrivate'], "127.0.0.1") if not check_captcha.is_valid: WZ['ErrorMessage'] = "[FP01]: Captcha response was incorrect." else: users = User.objects.all(). \ filter(username__exact=form.cleaned_data['login_id']). \ filter(email__exact=form.cleaned_data['email']) if len(users) == 1: temporary_password = GenerateTemporaryPassword() users[0].set_password(temporary_password) users[0].save() users[0].name.password_timeout = int(time()) users[0].name.save() send_mail( 'Password Reset', 'A password reset request for your account has been received and a new ' + \ 'temporary password has been assigned (see below). Visit ' + WZ['httpURL'] + '/login ' + \ 'within the next 20 minutes and choose a new permanent password. If you need more ' + \ 'time, you may visit ' + WZ['httpURL'] + '/fgpwd at any time to request another ' + \ 'temporary password.\n\nLogin ID: ' + users[0].username + \ '\nTemporary password: '******'AdminEmail'], [users[0].email], fail_silently=False) WZ['ErrorMessage'] = "[FP02]: Temporary password sent to your email." else: WZ['ErrorMessage'] = "[FP03]: Invalid Login ID/email." else: WZ['ErrorMessage'] = str(form.errors) else: form = ForgotPasswordForm() captcha_html = captcha.displayhtml(WZ['CaptchaPublic'], use_ssl = True) c = { 'form': form, 'WZ': WZ, 'captcha_html': captcha_html } c.update(csrf(request)) return render_to_response('UserForgotPassword.html', c )
def post(self): challenge = self.request.get('recaptcha_challenge_field') response = self.request.get('recaptcha_response_field') cResponse = captcha.submit(challenge, response, CAPTCHA_PRIVATE_KEY, REMOTE_ADDR) valid = True errors=None if cResponse.is_valid: username = self.request.get('username') user = UserModel.find_by_username(username) if not (user is None): valid = False errors=["Usuario %s ya existe "% username] else: validation = validateForm(self.request.POST, NewHandler.FIELD_COND) if(not validation[0]): valid = False errors = validation[1] else: password = self.request.get('password') passwordConfirmation = self.request.get('passwordConfirmation') if(password != passwordConfirmation): valid = False errors = ["Las contrasenas no coinciden"] else: hashed_pass = hashlib.sha224(password).hexdigest() name = self.request.get('name') email = self.request.get('email') if(self.request.get('isadmin') and self.request.get('isadmin')=="True"): usertype="Admin" else: usertype = "User" user = UserModel(key=ndb.Key('UserModel', username), username=username, name=name, email=email, active=False, usertype=usertype, password=hashed_pass) user.put() self.redirect('/') else: valid= False errors = ["Captcha not valid"] if not valid: error = cResponse.error_code chtml = captcha.displayhtml(public_key = CAPTCHA_PUBLIC_KEY,use_ssl = False,error = None) template_values = {'captchahtml':chtml, "errors" : errors, "session": self.session} template = JINJA_ENVIRONMENT.get_template('/user/new.html') self.response.write(template.render(template_values))
def get(self, slug): article = Article.get_for_slug(slug) comments = None chtml = captcha.displayhtml( public_key = "6LdnKr8SAAAAANd9vNW6i-2yMeaEaO2vgeDWn3dh", use_ssl = False, error = None) if article: comments = Comment.get_all_by_articleId(article.id) template = 'show-single-article.html' articles = [article] more = None else: template = 'not-found.html' articles = [] self.response.out.write(self.render_articles(articles=articles, request=self.request, recent=self.get_recent(), template_name=template, comments=comments, chtml=chtml))
def register_user(request): global base_title global global_nav, user_nav title = base_title + "Register" global_navigation=global_nav() # If user is not logged on if not request.user.is_authenticated(): # Return user navigation for an anonymous session user_navigation = user_nav(False) # Set up captcha html. from settings import captcha_publickey, captcha_privatekey captcha_test = captcha.displayhtml(captcha_publickey) # If user has sent POST data (not logged in) if request.method == 'POST': registration_errors = [] # Error list ''' Check and validate data ''' # Is human? HumanTestResult = captcha.submit( request.POST["recaptcha_challenge_field"], request.POST["recaptcha_response_field"], captcha_privatekey, get_ip(request) ) # If not human: display errors if HumanTestResult.is_valid: # Matching passwords? password = v.clean_password(request.POST["passw"]) if not request.POST["passw"] == request.POST["repassw"]: registration_errors.append("Passwords don't match.") if password == None: registration_errors.append("No password entered.") elif password == -1: registration_errors.append("Passwords have to be at least 5 characters.") # Username related errors username = v.clean_username(request.POST["usern"]) if username == None: registration_errors.append("No username entered.") elif username == -2: registration_errors.append("This username isn't available.") elif username == -1: registration_errors.append("Username's can only be 30 characters.") elif username == False: registration_errors.append("Username wasn't just characters numbers ") # Email related errors email = v.clean_email(request.POST["email"]) if email == None: registration_errors.append("No email entered.") elif email == -2: registration_errors.append("This email already has an account.") elif email == -1: registration_errors.append("Emails can only be 245 characters.") elif email == False: registration_errors.append("Invalid email.") # Invalid CAPTCHA, display only that error giving no more information to the bot else: registration_errors.append("Invalid human verification code.") captcha_test = captcha.displayhtml( captcha_publickey, False, HumanTestResult.error_code ) # Connect to SMTP server connection = mail.get_connection() connection.open() # If no errors: create user. if len(registration_errors) == 0: new_user = User.objects.create_user( username, email, request.POST["repassw"] ) new_user.is_active = True new_user.save() # Create activation key and user profile activation_key = KeyGen() # Add 2 hours so a recovery key can be made instantly after # account creation. thetime = new_user.date_joined + datetime.timedelta(hours=2) profile = UserProfile( activate_key=activation_key, activated=False, recovery_time=thetime, user=new_user) profile.save() # User is created and saved. Send an activation link via email # Activation link message_activateurl = baseurl+"/activate/?key="+str(activation_key) message_activateurl = message_activateurl+"&user="******"/deactivate/?key="+str(activation_key) message_deactivateurl = message_deactivateurl+"&user="******"<$user>", str(new_user.username)) message = message.replace("<$activatelink>", message_activateurl) message = message.replace("<$disablelink>", message_deactivateurl) # Send email email = EmailMessage( "Account Activation", message, EMAIL_HOST_USER, [new_user.email] ) email.send() connection.close() # Return new account page accountname = new_user.username response = render_to_response( 'auth/newaccount.html', locals(), context_instance=RequestContext(request) ) else: # Return registration form with errors in registration_errors response = render_to_response( 'auth/registration.html', locals(), context_instance=RequestContext(request) ) # If user hasn't sent POST data (not logged on) else: response = render_to_response( 'auth/registration.html', locals(), context_instance=RequestContext(request) ) # User is logged on else: user_navigation = user_nav(request.user.username) error = "You cannot register while logged in." response = render_to_response( 'error.html', locals() ) return response
def recover_user(request): global base_title global global_nav, user_nav title = base_title + "Recovery" global_navigation=global_nav() # If user is not logged on if not request.user.is_authenticated(): # Return user navigation for an anonymous session user_navigation = user_nav(False) # Set up captcha html. captcha_test = captcha.displayhtml(captcha_publickey) # If user has sent POST data (not logged in) if request.method == 'POST': # Check info via regex u_name = v.clean_usernameRE(request.POST["usern"]) email = v.clean_emailRE(request.POST["email"]) if email == request.POST["email"] and u_name: try: user = User.objects.get(username__iexact=u_name) user_profile = get_or_create_profile(user) # Current time time_now = now() # Recovery time recovery_time = user_profile.recovery_time if time_now > recovery_time: # Key has been requested too many times in 2 hours. error = "Recovery keys can only be requested once every 2 hours." response = render_to_response( 'error.html', locals() ) else: # Connect to SMTP server connection = mail.get_connection() connection.open() # Create a recovery key user_profile.recovery_key = KeyGen() user_profile.save() # Create account recovery link message_recoveryurl = baseurl+"/recover/?key="+str(user_profile.recovery_key) message_recoveryurl = message_recoveryurl+"&user="******"<$user>", str(user.username)) message = message.replace("<$recoverylink>", message_recoveryurl) message = message.replace("<$time>", str(user_profile.recovery_time)) # Send email email = EmailMessage( "Account Recovery", message, EMAIL_HOST_USER, [user.email] ) email.send() connection.close() # Tell user to check their email. error = "Check your email for a recovery link." response = render_to_response( 'error.html', locals() ) except User.DoesNotExist: error = "No user with that email exists." response = render_to_response( 'error.html', locals() ) else: error = "No user with that email exists." response = render_to_response( 'error.html', locals() ) else: # Didn't submit, give recovery form. response = render_to_response( 'auth/recovery.html', locals(), context_instance=RequestContext(request) ) # You're signed in, no recovery for you. else: return HttpResponseRedirect('/') return response
def recaptcha(context): return {'captcha': captcha.displayhtml(RECAPTCHA_PUB_KEY)}
def register(request, success_url=None, form_class=RegistrationForm, template_name='registration/registration_form.html', extra_context=None): """ Allow a new user to register an account. Following successful registration, issue a redirect; by default, this will be whatever URL corresponds to the named URL pattern ``registration_complete``, which will be ``/accounts/register/complete/`` if using the included URLConf. To change this, point that named pattern at another URL, or pass your preferred URL as the keyword argument ``success_url``. By default, ``registration.forms.RegistrationForm`` will be used as the registration form; to change this, pass a different form class as the ``form_class`` keyword argument. The form class you specify must have a method ``save`` which will create and return the new ``User``. By default, use the template ``registration/registration_form.html``; to change this, pass the name of a template as the keyword argument ``template_name``. **Required arguments** None. **Optional arguments** ``form_class`` The form class to use for registration. ``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. ``success_url`` The URL to redirect to on successful registration. ``template_name`` A custom template to use. **Context:** ``form`` The registration form. Any extra variables supplied in the ``extra_context`` argument (see above). **Template:** registration/registration_form.html or ``template_name`` keyword argument. """ test_cookie_worked = True if request.method == 'POST': # Check the test cookie test_cookie_worked = request.session.test_cookie_worked() if test_cookie_worked: request.session.delete_test_cookie() # Check the captcha if settings.ACCOUNT_REGISTRATION_USE_RECAPTCHA: try: check_captcha = captcha.submit(request.POST['recaptcha_challenge_field'], request.POST['recaptcha_response_field'], settings.RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR']) except KeyError: # To avoid getting error e-mails when spammers fail at scripting ;) check_captcha = captcha.RecaptchaResponse(is_valid=False) # Check the form form = form_class(data=request.POST, files=request.FILES) if form.is_valid() and test_cookie_worked and (not(settings.ACCOUNT_REGISTRATION_USE_RECAPTCHA) or check_captcha.is_valid): new_user = form.save() # success_url needs to be dynamically generated here; setting a # a default value using reverse() will cause circular-import # problems with the default URLConf for this application, which # imports this file. return HttpResponseRedirect(success_url or reverse('registration_complete')) if settings.ACCOUNT_REGISTRATION_USE_RECAPTCHA and not(check_captcha.is_valid): form.errors['captcha'] = '<ul class="errorlist"><li>Incorrect CAPTCHA solution.</li></ul>' else: form = form_class() if extra_context is None: extra_context = {} request.session.set_test_cookie() context = RequestContext(request) for key, value in extra_context.items(): context[key] = callable(value) and value() or value html_captcha = None if settings.ACCOUNT_REGISTRATION_USE_RECAPTCHA: html_captcha = captcha.displayhtml(settings.RECAPTCHA_PUB_KEY) return render_to_response(template_name, { 'form': form, 'captcha': html_captcha, 'test_cookie_worked': test_cookie_worked, }, context_instance=context)
def showCaptcha(self): """ """ return captcha.displayhtml(getattr(self, 'public_key'))
def post(self): fullname = self.request.get("fullname") email1 = self.request.get("email1") email2 = self.request.get("email2") subject = self.request.get("subject") body = self.request.get("body") pageParams = checkLogin(self) pageParams['email1'] = self.request.get('email1') pageParams['email2'] = self.request.get('email2') pageParams['fullname'] = self.request.get('fullname') pageParams['subject'] = self.request.get('subject') pageParams['body'] = self.request.get('body') challenge = self.request.get('recaptcha_challenge_field') response = self.request.get('recaptcha_response_field') remoteip = environ['REMOTE_ADDR'] pageParams['captcha'] = captcha.displayhtml(public_key = "6Lc_gb8SAAAAAJWVBIquKY9vHVQEAyhRitnxYb3A",use_ssl=False, error=None) cResponse = captcha.submit(challenge,response,"6Lc_gb8SAAAAAK85P9VLyReVYFy15xkqP1DBrBxa",remoteip) if not cResponse.is_valid: pageParams['error'] = cResponse.error_code self.response.out.write( template.render('contact.html', pageParams)) return if fullname is None or len(fullname) == 0: pageParams['error'] = "Please provide your name." self.response.out.write( template.render('contact.html', pageParams)) return if email1 is None or len(email1) == 0: pageParams['error'] = "Email address required." self.response.out.write( template.render('contact.html', pageParams)) return if email2 is None or len(email2) == 0: pageParams['error'] = "Email address confirmation required." self.response.out.write( template.render('contact.html', pageParams)) return if email1 != email2: pageParams['error'] = "Email confirmation failed. Please enter your email again." self.response.out.write( template.render('contact.html', pageParams)) return if subject is None or len(subject) == 0: pageParams['error'] = "Subject required." self.response.out.write( template.render('contact.html', pageParams)) return if body is None or len(body) == 0: pageParams['error'] = "Your message is empty." self.response.out.write( template.render('contact.html', pageParams)) return msg = template.render('contact.eml', pageParams) mail.send_mail(sender='CryptoEditor <'+senderEmailAddress+'>', to=supportEmailAddress, subject=subject, body=msg) pageParams['message'] = "Your message has been sent with success." self.response.out.write( template.render('contact.html', pageParams))
def recover_user(request): global base_title global global_nav, user_nav title = base_title + "Recovery" global_navigation = global_nav() # If user is not logged on if not request.user.is_authenticated(): # Return user navigation for an anonymous session user_navigation = user_nav(False) # Set up captcha html. captcha_test = captcha.displayhtml(captcha_publickey) # If user has sent POST data (not logged in) if request.method == 'POST': # Check info via regex u_name = v.clean_usernameRE(request.POST["usern"]) email = v.clean_emailRE(request.POST["email"]) if email == request.POST["email"] and u_name: try: user = User.objects.get(username__iexact=u_name) user_profile = get_or_create_profile(user) # Current time time_now = now() # Recovery time recovery_time = user_profile.recovery_time if time_now > recovery_time: # Key has been requested too many times in 2 hours. error = "Recovery keys can only be requested once every 2 hours." response = render_to_response('error.html', locals()) else: # Connect to SMTP server connection = mail.get_connection() connection.open() # Create a recovery key user_profile.recovery_key = KeyGen() user_profile.save() # Create account recovery link message_recoveryurl = baseurl + "/recover/?key=" + str( user_profile.recovery_key) message_recoveryurl = message_recoveryurl + "&user="******"<$user>", str(user.username)) message = message.replace("<$recoverylink>", message_recoveryurl) message = message.replace( "<$time>", str(user_profile.recovery_time)) # Send email email = EmailMessage("Account Recovery", message, EMAIL_HOST_USER, [user.email]) email.send() connection.close() # Tell user to check their email. error = "Check your email for a recovery link." response = render_to_response('error.html', locals()) except User.DoesNotExist: error = "No user with that email exists." response = render_to_response('error.html', locals()) else: error = "No user with that email exists." response = render_to_response('error.html', locals()) else: # Didn't submit, give recovery form. response = render_to_response( 'auth/recovery.html', locals(), context_instance=RequestContext(request)) # You're signed in, no recovery for you. else: return HttpResponseRedirect('/') return response
def post(self): challenge = self.request.get('recaptcha_challenge_field') response = self.request.get('recaptcha_response_field') remoteip = environ['REMOTE_ADDR'] cResponse = captcha.submit( challenge, response, recaptcha_private_key, remoteip) if cResponse.is_valid: success = True else: error = cResponse.error_code success = False chtml = captcha.displayhtml( public_key = recaptcha_public_key, use_ssl = False, error = cResponse.error_code) template_values = { 'error': cResponse.error_code, 'event': self.request.get('event'), 'venue': self.request.get('venue'), 'description': self.request.get('description'), 'categories': categories(), 'selectedcategory': self.request.get('category'), 'eventdate': self.request.get('eventdate'), 'eventtime': self.request.get('eventtime'), 'email': self.request.get('email'), 'private': self.request.get('private'), 'captchahtml': chtml } if (success == True): # Create a uniqie, guid name for the event. This fixes the problem of everyone having to have a unique event name. # uniquename = str(uuid.uuid4()).split("-")[0] uniquename = str(uuid.uuid4()).split("-")[0] + '/' + self.request.get('event').replace(' ', '-').replace('&', 'and').replace('\'', '').replace('\"', '').replace('.', '').replace("!", "").replace("@", "at").replace("*", "") password = str(uuid.uuid4()).split("-")[0] # Create a new Promotion record. promotion = Promotion() promotion.uniquename = uniquename promotion.venue = self.request.get('venue') promotion.event = self.request.get('event') promotion.description = db.Text(self.request.get('description')) promotion.date = self.request.get('eventdate') promotion.time = self.request.get('eventtime') promotion.email = self.request.get('email') promotion.category = self.request.get('category') promotion.password = password # Set if event is private or not. if not (self.request.get('private') == ''): promotion.private = True else: promotion.private = False image = str(self.request.get("image")) if not image is "": imageresized = images.resize(image, 453) promotion.image = db.Blob(imageresized) imagethumb = images.resize(image, 30) promotion.imagethumbnail = db.Blob(imagethumb) promotion.imageoriginal = db.Blob(image) promotion.put() # Create email and send to user. message = mail.EmailMessage(sender="PartyPlannr Support <*****@*****.**>", subject="New PartyPlannr Event Created") message.to = self.request.get('email') message.body = """ Your event has been created: "%s" To view your event click the link below: http://www.partyplannr.com/%s Please let us know if you have any questions. PartyPlannr """ % (self.request.get('event'), uniquename) #self.response.out.write(message.body) message.send() # Redirect to the new URL for the event. self.redirect("/%s" % uniquename, True) else: path = os.path.join(os.path.dirname(__file__), 'index.html') self.response.out.write(template.render(path, template_values))
def get(self): chtml = captcha.displayhtml(public_key = NewHandler.CAPTCHA_PUBLIC_KEY,use_ssl = False,error = None) template_values = {'captchahtml': chtml, "session": self.session} template = JINJA_ENVIRONMENT.get_template('user/new.html') self.response.write(template.render(template_values))
def renderInPage(self): """ Render comments form in page context. """ _ = self.macro.request.getText html = u"""<div class="comments_form"> <form method="POST" action="%(page_uri)s"> <input type="hidden" name="do" value="comment_add"> <table>""" % { "page_uri": self.macro.request.request_uri } html += """ <tr> <td colspan=2 id="center_cell"><b>%(header)s</b></td> </tr> <tr> <th>%(name_label)s</th> <td> <input type="text" id="name" maxlength=128 name="user_name" value="%(user_name)s"> </td> </tr> <tr> <th>%(comment_label)s</th> <td> <textarea name="comment">%(comment)s</textarea> </td> </tr> """ % { "page_name": self.page_name, "user_name": self.comment["user_name"], "comment": self.comment["comment"], "header": _("Comment this page"), "name_label": _("Name:"), "comment_label": _("Comment:"), } if self.msg: html += u'<tr><td colspan = 2><div id="comment_message">' html += u"<p>%s</p>" % self.msg html += u"</div></td></tr>" if self.errors: html += u'<tr><td colspan = 2><div id="comment_error">' if len(self.errors) > 1: html += u"<p>%s</p><ul>" % _("Your comment has errors:") else: html += u"<p>%s</p><ul>" % _("Your comment has one error:") for error in self.errors: html += u"<li>%s</li>" % error html += u"</ul></div></td></tr>" if get_cfg(self.macro, "comment_recaptcha", False): import captcha html += u""" <tr> <th>%(recaptcha_label)s</th> <td>%(recaptcha)s</td> </tr>""" % { "recaptcha": captcha.displayhtml(get_cfg(self.macro, "comment_recaptcha_public_key")), "recaptcha_label": _("Are you human?"), } html += """ <tr> <td colspan=2 id="center_cell"><input type="submit" value="%(label)s"> </td> </tr> </table></form></div>""" % { "label": _("Send comment") } try: return self.macro.formatter.rawHTML(html) except: return self.macro.formatter.escapedText("")
from django.contrib import admin from django.contrib.sitemaps import FlatPageSitemap, GenericSitemap from django.views.generic import list_detail from django.views.decorators.cache import cache_page from colddirt.dirty.models import Dirt, Word from colddirt.dirty import views from colddirt.feeds import LatestDirts, PerDirt from colddirt.forms import * import captcha rand_dict = { 'queryset': Dirt.objects.order_by('?')[:250], 'template_object_name' : 'dirty', 'paginate_by': 15, 'extra_context': {'form': DirtyForm().as_ul(), 'html_captcha': captcha.displayhtml(settings.RECAPTCHA_PUB_KEY)} } newdirt_dict = { 'queryset': Dirt.objects.order_by('-publish_date')[:250], 'template_object_name' : 'dirty', 'paginate_by': 15, 'extra_context': {'form': DirtyForm().as_ul(), 'html_captcha': captcha.displayhtml(settings.RECAPTCHA_PUB_KEY)} } word_dict = { 'queryset': Dirt.objects.all(), 'template_object_name' : 'dirt_object', 'extra_context': {'form': DirtyForm().as_ul(), 'html_captcha': captcha.displayhtml(settings.RECAPTCHA_PUB_KEY)}
t = jinja_env.get_template(template) return t.render(params) def render(self, template, **kw): self.write(self.render_str(template, **kw)) class Post(db.Model): content = db.TextProperty(required=True) created = db.DateTimeProperty(auto_now_add=True) lang = db.StringProperty() name = db.StringProperty() chtml = captcha.displayhtml( public_key="6Lf4R9QSAAAAAJ5HtpuRxDFBbEIyENx8RYvJLwJO", use_ssl=False, error=None) class NewPost(Handler): def render_newpost(self, name="", content="", error=""): global chtml self.render("newpost.html", name=name, content=content, error=error, chtml=chtml) def get(self): self.render_newpost()
def render(self, name, value, attrs=None): html = captcha.displayhtml(settings.RECAPTCHA_PUBLIC_KEY) return mark_safe(u'%s' % html)
def recaptcha(context): return {"captcha": captcha.displayhtml(RECAPTCHA_PUB_KEY)}
def render(self, name, value, attrs=None): return mark_safe(u'%s' % captcha.displayhtml(settings.RECAPTCHA_PUBLIC_KEY))
def get(self): pageParams = checkLogin(self) pageParams['captcha'] = captcha.displayhtml(public_key = "6Lc_gb8SAAAAAJWVBIquKY9vHVQEAyhRitnxYb3A",use_ssl=False, error=None) self.response.out.write( template.render('contact.html', pageParams))
def render_str(self, template, **params): t = jinja_env.get_template(template) return t.render(params) def render(self, template, **kw): self.write(self.render_str(template, **kw)) class Post(db.Model): content = db.TextProperty(required = True) created = db.DateTimeProperty(auto_now_add = True) lang = db.StringProperty() name = db.StringProperty() chtml = captcha.displayhtml( public_key = "6Lf4R9QSAAAAAJ5HtpuRxDFBbEIyENx8RYvJLwJO", use_ssl = False, error = None) class NewPost(Handler): def render_newpost(self, name="", content="", error=""): global chtml self.render("newpost.html", name=name, content=content, error=error, chtml=chtml) def get(self): self.render_newpost() def post(self): name = self.request.get("name") content = self.request.get("content") lang = self.request.get("lang") challenge = self.request.get('recaptcha_challenge_field')
def register_user(request): global base_title global global_nav, user_nav title = base_title + "Register" global_navigation = global_nav() # If user is not logged on if not request.user.is_authenticated(): # Return user navigation for an anonymous session user_navigation = user_nav(False) # Set up captcha html. from settings import captcha_publickey, captcha_privatekey captcha_test = captcha.displayhtml(captcha_publickey) # If user has sent POST data (not logged in) if request.method == 'POST': registration_errors = [] # Error list ''' Check and validate data ''' # Is human? HumanTestResult = captcha.submit( request.POST["recaptcha_challenge_field"], request.POST["recaptcha_response_field"], captcha_privatekey, get_ip(request)) # If not human: display errors if HumanTestResult.is_valid: # Matching passwords? password = v.clean_password(request.POST["passw"]) if not request.POST["passw"] == request.POST["repassw"]: registration_errors.append("Passwords don't match.") if password == None: registration_errors.append("No password entered.") elif password == -1: registration_errors.append( "Passwords have to be at least 5 characters.") # Username related errors username = v.clean_username(request.POST["usern"]) if username == None: registration_errors.append("No username entered.") elif username == -2: registration_errors.append( "This username isn't available.") elif username == -1: registration_errors.append( "Username's can only be 30 characters.") elif username == False: registration_errors.append( "Username wasn't just characters numbers ") # Email related errors email = v.clean_email(request.POST["email"]) if email == None: registration_errors.append("No email entered.") elif email == -2: registration_errors.append( "This email already has an account.") elif email == -1: registration_errors.append( "Emails can only be 245 characters.") elif email == False: registration_errors.append("Invalid email.") # Invalid CAPTCHA, display only that error giving no more information to the bot else: registration_errors.append("Invalid human verification code.") captcha_test = captcha.displayhtml(captcha_publickey, False, HumanTestResult.error_code) # Connect to SMTP server connection = mail.get_connection() connection.open() # If no errors: create user. if len(registration_errors) == 0: new_user = User.objects.create_user(username, email, request.POST["repassw"]) new_user.is_active = True new_user.save() # Create activation key and user profile activation_key = KeyGen() # Add 2 hours so a recovery key can be made instantly after # account creation. thetime = new_user.date_joined + datetime.timedelta(hours=2) profile = UserProfile(activate_key=activation_key, activated=False, recovery_time=thetime, user=new_user) profile.save() # User is created and saved. Send an activation link via email # Activation link message_activateurl = baseurl + "/activate/?key=" + str( activation_key) message_activateurl = message_activateurl + "&user="******"/deactivate/?key=" + str( activation_key) message_deactivateurl = message_deactivateurl + "&user="******"<$user>", str(new_user.username)) message = message.replace("<$activatelink>", message_activateurl) message = message.replace("<$disablelink>", message_deactivateurl) # Send email email = EmailMessage("Account Activation", message, EMAIL_HOST_USER, [new_user.email]) email.send() connection.close() # Return new account page accountname = new_user.username response = render_to_response( 'auth/newaccount.html', locals(), context_instance=RequestContext(request)) else: # Return registration form with errors in registration_errors response = render_to_response( 'auth/registration.html', locals(), context_instance=RequestContext(request)) # If user hasn't sent POST data (not logged on) else: response = render_to_response( 'auth/registration.html', locals(), context_instance=RequestContext(request)) # User is logged on else: user_navigation = user_nav(request.user.username) error = "You cannot register while logged in." response = render_to_response('error.html', locals()) return response