def comment(request, post_id):
    if request.method == 'POST':
        form = CommentForm(request.POST)
        if form.is_valid():
            if not request.user.is_authenticated():
                r = captcha.submit(request.POST['recaptcha_challenge_field'], request.POST['recaptcha_response_field'], settings.RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR'])
                if not r.is_valid:
                    return redirect('/blog/'+post_id+'/') # Invalid form entry
            f = form.save(commit=False);
          
            f.post_id = post_id
            if request.user.is_authenticated():
                f.author_id = request.user.id
                f.author_name = ''
                f.author_email = ''
            f.save()
        
            email_msg  = 'You have a new comment at http://www.jessicasteiber.com/blog/'+post_id+'/#comments'
            email_from = '[email protected]'
            email_to   = ['[email protected]', '[email protected]']
        
            # Send email notification
            send_mail('New Blog Comment - JessicaSteiber.com', email_msg, email_from, email_to)
        
            return redirect('/blog/'+post_id+'/#comments') # Go back to blog with new comment
        else:
            return redirect('/blog/'+post_id+'/') # Invalid form entry
    else:
        return redirect('/blog/'+post_id+'/') # Go back to blog

  def post(self):
    if self.get_logged_in_person():
      p = self.get_logged_in_person() 
      challenge = self.request.get('recaptcha_challenge_field')
      response  = self.request.get('recaptcha_response_field')
      remoteip  = environ['REMOTE_ADDR']

      cResponse = captcha.submit(
                     challenge,
                     response,
                     recaptcha_keys.recaptcha_private_key,
                     remoteip)

      if cResponse.is_valid:
          # response was valid
          p.ishuman = True
          p.put()
          self.render('confirm')
      else:
        error = cResponse.error_code

        chtml = captcha.displayhtml(
          public_key = recaptcha_keys.recaptcha_public_key,
          use_ssl = False,
          error = cResponse.error_code)

        template_values = {
          'captchahtml': chtml
        }
        self.render('home', template_values)

    else:
      self.redirect('/')

def register(request):
    captcha_error = ""
    captcha_valid = True
    if request.method == 'POST':
        form = RegistrationForm(request.POST)
        if settings.USE_CAPTCHA:        
            captcha_response = captcha.submit(request.POST.get("recaptcha_challenge_field", None),  
                                           request.POST.get("recaptcha_response_field", None),  
                                           settings.RECAPTCHA_PRIVATE_KEY,  
                                           request.META.get("REMOTE_ADDR", None))  
            captcha_valid = captcha_response.is_valid
        if not captcha_valid:  
            captcha_error = "&error=%s" % captcha_response.error_code 
        else:
            if form.is_valid():
                u = form.save()
                msg = render_to_string('registration/welcome.mail',
                            {'username': u.username},
                            context_instance = RequestContext(request))    
                u.email_user(_('Welcome to %(project)s') % {'project':settings.PROJECT_NAME}, msg)
                return render_to_response("contact/message.html",
                                          {'message': _('You can now sign in with the choosen username and password.')},
                                          context_instance = RequestContext(request))
    else:
        if request.user.is_authenticated():
            return HttpResponseRedirect(reverse('home'))
        
        form = RegistrationForm()
    return render_to_response("registration/register.html",
                              {'form': form,
                               'captcha_error': captcha_error,
                               'settings': settings},
                               context_instance = RequestContext(request))

def captcha_verify(request, post_pk, pk):
    """ Verify the captcha response. If it is invalid,
        inform the user. Otherwise allow the post to be listed. """
    post = Post.objects.get(pk=post_pk)
    comment = Comment.objects.get(pk=pk)

    response = captcha.submit(
        request.POST.get("recaptcha_challenge_field"),
        request.POST.get("recaptcha_response_field"),
        settings.GOOGLE_CAPTCHA_PRIVATE_API_KEY,
        request.META["REMOTE_ADDR"],
    )

    if response.is_valid:
        comment.listed = True
        comment.save()
        return HttpResponseRedirect(
            reverse("blog:index") + "%d/%.2d/%s/#comments" % (post.pub_date.year, post.pub_date.month, post.slug)
        )
    else:
        ctx = RequestContext(
            request,
            {
                "google_captcha_api_key": settings.GOOGLE_CAPTCHA_PUBLIC_API_KEY,
                "post": post,
                "comment": comment,
                "captcha_response": "Invalid Captcha.",
            },
        )
        return render_to_response("blog/captcha.html", ctx)

 def post(self):
     c = Comentario()
     c.contenido = cgi.escape(self.request.get('contenido'), True)
     c.id_enlace = self.request.get('id_enlace')
     c.os = self.request.environ['HTTP_USER_AGENT']
     c.ips = [self.request.remote_addr]
     if users.get_current_user() and self.request.get('contenido') and self.request.get('id_enlace'):
         if self.request.get('anonimo') != 'on':
             c.autor = users.get_current_user()
         self.finalizar( c )
     elif self.request.get('contenido') and self.request.get('id_enlace'):
         challenge = self.request.get('recaptcha_challenge_field')
         response = self.request.get('recaptcha_response_field')
         remoteip = self.request.remote_addr
         cResponse = captcha.submit(
             challenge,
             response,
             RECAPTCHA_PRIVATE_KEY,
             remoteip)
         if cResponse.is_valid:
             self.finalizar( c )
         else:
             self.redirect('/error/403c')
     else:
         self.redirect('/error/403')

def register(request):
    if request.method == 'POST':
        if 'recaptcha_challenge_field' in 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 not check_captcha.is_valid:
                messages.error(request, "Captcha was incorrect!") #% check_captcha.error_code)
                return HttpResponseRedirect(reverse('register'))

        form = RegisterForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            username,email,password = cd['username'], cd['email'], cd['password']   
            
            new_user = User.objects.create_user(username = username, email = email, password = password)  

            #TODO: fix this, weird postgres issue in django 1.3 see trac issue #15682
            user = User.objects.get(username=new_user.username)
            profile = UserProfile.objects.create(user=user)
            
            messages.success(request, "Thanks for registering %s! Welcome to tehorng." % new_user)
            
            authed_user = authenticate(username=username, password=password)
            login(request, authed_user)
            return HttpResponseRedirect(reverse('profile'))    
    else:
        form = RegisterForm(initial=request.POST)
    return render_to_response('registration/register.html', {
        'form': form,
        'captcha': mark_safe(captcha.displayhtml(settings.RECAPTCHA_PUBLIC_KEY)),
    }, context_instance=RequestContext(request))

    def captcha_check(self, *args, **kwargs):

        if not "recaptcha_challenge_field" in kwargs:
            raise cherrypy.HTTPRedirect("/new_user?error=No captcha challenge field. That is totally weird. Please try reloading the page.")

        if not "recaptcha_response_field" in kwargs:
            raise cherrypy.HTTPRedirect("/new_user?error=No captcha response field. That is totally weird. Please try reloading the page.")


        recaptcha_challenge_field = kwargs["recaptcha_challenge_field"]
        recaptcha_response_field = kwargs["recaptcha_response_field"]

        captcha_results = captcha.submit(
                recaptcha_challenge_field,
                recaptcha_response_field,
                cherrypy.request.app.config["captcha"]["private"],
                cherrypy.request.headers["Remote-Addr"],)

        if captcha_results.is_valid:
            # TODO redirect to "your email should get a code" page
            return "valid"

        if captcha_results.error_code:
            # needs an error message
            if captcha_results.error_code == "invalid-site-private-key":
                # TODO log and alert operator
                pass
            raise cherrypy.HTTPRedirect("/new_user?error=%s"%
                    captcha_results.error_code)

def suggest_resource(request, **kwargs):

    suggest = None
    output = {}
    template = ''
    captcha_is_valid = True
    captcha_error = ''
    
    suggest = SuggestResource()
   
    form = ExternalSuggestResourceForm(request.POST, instance=suggest)

    if settings.RECAPTCHA_PRIVATE_KEY:
        # Check the captcha with reCAPTCHA (google service)
        captcha_response = captcha.submit(  
            request.POST.get('recaptcha_challenge_field'),  
            request.POST.get('recaptcha_response_field'),  
            settings.RECAPTCHA_PRIVATE_KEY,  
            request.META['REMOTE_ADDR'],)  

        if not captcha_response.is_valid:
            # captcha is wrong show a error message in the template.
            captcha_is_valid = False
            captcha_error = captcha_response.error_code           

    if form.is_valid() and captcha_is_valid:
        template = 'suggest/thanks.html'
        suggest = form.save()
    else:
        template = 'suggest/invalid-link.html'
        output['form'] = form
        output['captcha_error'] = captcha_error
    
    return render_to_response(template, output, context_instance=RequestContext(request))

def index(request):
    info = {}
    
    info['links'] = Link.objects.filter(is_public=True)
    
    if request.method == 'POST': # If the form has been submitted...
        form = ContactForm(request.POST) # A form bound to the POST data
        if form.is_valid(): # All validation rules pass
            r = captcha.submit(request.POST['recaptcha_challenge_field'], request.POST['recaptcha_response_field'], settings.RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR'])
            if not r.is_valid:
                return redirect('/contact/') # Invalid form entry
            
            # Process the data in form.cleaned_data
            name = form.cleaned_data['name']
            email = form.cleaned_data['email']
            message = form.cleaned_data['message']
            recipients = ['[email protected]', '[email protected]']
            
            email = EmailMessage('Contact Message From ' + name + ' - JessicaSteiber.com', message, email, recipients)
            email.send()
            
            info['msg'] = '<p class="success">Message successfully sent.</p>'
            info['form'] = ContactForm()
    else:
        info['form'] = ContactForm() # An unbound form
        info['msg'] = ''
    
    verses = Verse.objects.filter(is_public=True).order_by('?')
    info['verse'] = verses[0]
    
    info['active'] = 'contact'
    
    return render_to_response('contact/index.html', { 'info': info }, context_instance=RequestContext(request))

def save_child(request,parent=None,parentString=''):
	request.session['errors'] = ''
	if settings.USE_RECAPTCHA:
		response = captcha.submit(request.POST.get('recaptcha_challenge_field'),request.POST.get('recaptcha_response_field'),settings.RECAPTCHA_PRIVATE_KEY,request.META['REMOTE_ADDR']) 
		if not response.is_valid:
			request.session['errors'] = 'captcha'
			return redirect(settings.URL_ROOT+parentString)

	email = request.POST.get('email', '')
	request.session['email'] = email
	if not is_valid_email(email):
		request.session['errors'] = 'email'
		return redirect(settings.URL_ROOT+parentString) #invalid email, send back to start
	hash = hash_email(email)
	ip = request.META.get('REMOTE_ADDR')
	slider = 50
	newp = Person.objects.filter(email = email)
	dup = (len(newp) > 0)
	if dup:
		newp = newp[0]
		rating = Rating.objects.filter(person = newp)
		if len(rating) > 0:
			slider = rating[0].rating
	else:
		if parent == None or len(parent) == 0:
			newp = Person(email = email, hash = hash, ipaddress=ip, influence=0,parent_node=None,session_key=str(request.session.session_key))
			newp.save()
		else:
			newp = Person(email = email, hash = hash, ipaddress=ip, parent=parent[0].email,parent_node=parent[0],influence=0, session_key=str(request.session.session_key))
			newp.save()
			update_score(newp)
	t = loader.get_template('save.html')
	c = RequestContext(request, {'link':settings.URL_ROOT+str(newp.id),'score_link':settings.URL_ROOT+'score/'+str(newp.id),'csrf_token':csrf(request)['csrf_token'],'url':settings.URL_ROOT,'saved': '','slider': slider,'dup':dup})
	return HttpResponse(t.render(c))

 def validate(self, value):
     captchaResponse = captcha.submit(value['recaptcha_challenge_name'], 
                                      value['recaptcha_response_name'], 
                                      settings.RECAPTCHA_PRIVATE_KEY, 
                                      '')
     if not captchaResponse.is_valid:
         raise ValidationError(self.default_error_messages['invalid_answer'])

 def clean(self):
     error_list = []
    
     # Test userName is unique
     if 'userName' in self.cleaned_data:
         QS = User.objects.filter(username__exact=self.cleaned_data['userName'])
         if QS.count(): error_list.append("username '%s' is already in use" % (self.cleaned_data['userName']))
     
     # Test emailAddress
     if 'email' in self.cleaned_data:
         validaton_errorList = validate_email(self.cleaned_data['email'])
         if validaton_errorList:
             error_list += validaton_errorList            
         
     # Test passwords
     if 'pass1' in self.cleaned_data and 'pass2' in self.cleaned_data:
         validaton_errorList = validate_passwords(self.cleaned_data['pass1'], self.cleaned_data['pass2'])
         if validaton_errorList:
             error_list += validaton_errorList        
 
     # test if captcha is valid
     captcha_response = captcha.submit(self.recaptcha_challenge_field,  
                                       self.recaptcha_response_field,  
                                       settings.RECAPTCHA_PRIVATE_KEY,  
                                       self.REMOTE_ADDR) 
     if not captcha_response.is_valid:  
         error_list.append("incorrect captcha")
     
     if error_list: raise ValidationError(error_list)
     return self.cleaned_data        

def register(request):
    if request.method == "POST":
        if "recaptcha_challenge_field" in 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 not check_captcha.is_valid:
                messages.error(request, "Captcha didn't pan out! '%s'" % check_captcha.error_code)
                return HttpResponseRedirect(reverse("register"))

        form = RegisterForm(request.POST)
        if form.is_valid():
            cd = form.cleaned_data
            username, email, password = cd["username"], cd["email"], cd["password"]
            new_user = User.objects.create_user(username=username, email=email, password=password)
            profile = UserProfile.objects.create(user=new_user)
            messages.success(request, "Thanks for registering %s! Welcome to tehorng." % new_user)

            authed_user = authenticate(username=username, password=password)
            login(request, authed_user)
            return HttpResponseRedirect(reverse("profile"))
    else:
        form = RegisterForm()
    return render_to_response(
        "registration/register.html",
        {"form": form, "captcha": mark_safe(captcha.displayhtml(settings.RECAPTCHA_PUBLIC_KEY))},
        context_instance=RequestContext(request),
    )

  def post(self):
    target_name = self.request.get('id')
    message = self.request.get('email_message') or None
    sender_email = self.request.get('email_address') or ''
    target = get_target(target_name)

    if not target:
      self.response.set_status(404)
      return

    if target.anonymous:
      response = captcha.submit(
          self.request.get('recaptcha_challenge_field'),
          self.request.get('recaptcha_response_field'),
          RECAPTCHA_PRIVATE_KEY,
          self.request.remote_addr)
      if not response.is_valid:
        logging.info('reCaptcha failed: error_code=%s', response.error_code)
        self.response.set_status(400)
        return
      reply_to = sender_email
    else:
      current_user = users.get_current_user()
      if not current_user:
        self.response.set_status(400)
        return
      reply_to = current_user.email()

    taskqueue.add(
        url='/work/send_email',
        params=dict(target_name=target_name,
                    reply_to=reply_to,
                    message=message),
        queue_name='send')
    logging.info('Enqueued email for target=%s', target_name)

    def processPublicRegistration(self):
        log = logging.getLogger('csdt')
        log.debug("register_view.processPublicRegistration()")

        log.debug("context = %s" % self.context)
        log.debug("request = %s" % self.request)
        session = self.request.session

        log.debug("request values:")
        for k, v in self.request.params.iteritems():
            log.debug("key = %s value = %s" % (k, v))

        log.debug("session values:")
        for k, v in session.iteritems():
            log.debug("key = %s value = %s" % (k, v))
        
        if "first_name" not in self.request.params or "last_name" not in self.request.params or "email" not in self.request.params:
            log.warning("request.params is missing a parameter that is essential")
            raise HTTPNotFound()

        self.nonUsersOnlyAuthorization(session)

        host = self.request.host
        recaptcha_private_key = '6Ldi2MYSAAAAALJ_KaLfTzOTAg5iNHqOmvmgaQOg'
        captcha_result = captcha.submit(
            self.request.params['recaptcha_challenge_field'],
            self.request.params['recaptcha_response_field'],
            recaptcha_private_key,
            host,
        )
        if not captcha_result.is_valid:
            error = captcha_result.error_code
            json_hash = {'result': '-1', 'error':error}
            json_dump = json.dumps(json_hash)
            log.debug("json dump = %s" % json_dump)

            return Response(json_dump)

        first_name = self.request.params['first_name']
        last_name = self.request.params['last_name']
        email = self.request.params['email']
   
        user_id = self.context.doesEmailExist(email)
        if user_id is not None:
            json_hash = {'result': '-2'}
            json_dump = json.dumps(json_hash)
            log.debug("json dump = %s" % json_dump)

            return Response(json_dump)

        plaintext = first_name + ";" + last_name + ";" + email
        ciphertext = self.context.encryptUrlQuery(unicode(plaintext))

        self.context.createConfirmationLetter(self.request.host_url, email, first_name, last_name, ciphertext)

        json_hash = {'result': '0'}
        json_dump = json.dumps(json_hash)
        log.debug("json dump = %s" % json_dump)

        return Response(json_dump)

def contact(request):
    '''
    Display and process the contact form.
    
    Keyword arguments:
    request -- the request object.
    
    Return:
    The contact form view (if pre-request) or a view with a success
    message.
    '''
    
    CAPTCHA_PUBLIC_KEY = settings.AF_RECAPTCHA_PUBLIC_KEY
    
    if request.method == 'POST':
        
        form = contactForm(request.POST)        
        
        if form.is_valid():
	    
	    # Check if the response CAPTCHA value is valid; else redirect back
	    # with an error.
            response = captcha.submit(  
                        request.POST.get('recaptcha_challenge_field'),  
                        request.POST.get('recaptcha_response_field'),  
                        settings.AF_RECAPTCHA_PRIVATE_KEY,  
                        request.META['REMOTE_ADDR'],)         
            
            if not response.is_valid:
		
                captchaWrong = True
                return render_to_response('contact.html', locals(), 
                              context_instance=RequestContext(request))
            
            subject = request.POST['userSubject']
            
            message = "Hello, you've received a message from AfterGlow Cloud.\n"
            
            message += "User: " + request.POST["userName"] + " (" \
                + request.POST["userEmail"] + ") says: \n\n"
            
            message += request.POST["userMessage"]
            
            from_email = settings.AF_FROM_EMAIL
	    
            try:
                send_mail("AfterGlow: " + subject, message, 
                          from_email, settings.AF_TO_EMAILS)
            except BadHeaderError:
                return HttpResponse('Invalid header found. Please try again.')
            
            # Boolean flag used to display a 'success' message on the view.
            mailSent = True

    else:
	
        form = contactForm()
    
    return render_to_response('contact.html', locals(), 
                              context_instance=RequestContext(request))

    def wrapped(config,
                users,
                messages,
                *args,
                **kwargs):
      if config.captcha.enabled:
        from recaptcha.client import captcha

        challenge = bottle.request.POST.pop('recaptcha_challenge_field', None)
        response = bottle.request.POST.pop('recaptcha_response_field', None)

        if challenge is None or response is None:
          messages.error('Captcha values are missing')
          bottle.redirect('/')

        result = captcha.submit(challenge,
                                response,
                                config.captcha.recaptcha_private_key,
                                bottle.request.remote_addr)

        if not result.is_valid:
          messages.error('Captcha invalid')
          bottle.redirect(__on_error__)

      # Call the wrapped function
      return func(*args,
                  **kwargs)

def custom_register (request, *args, **kwargs):
    """
    Wrap the django-registration register view in a custom view, so that we can
    use reCAPTCHA.
    """
    if request.method == "POST":
        # Check the captcha
        check_captcha = captcha.submit(\
            request.POST["recaptcha_challenge_field"],
            request.POST["recaptcha_response_field"],
            settings.RECAPTCHA_PRIVATE_KEY,
            request.META["REMOTE_ADDR"])
        
        if not check_captcha.is_valid:
            # If the captcha is wrong, error
            form    = kwargs["form_class"](request.POST)
            context = {"form": form, "recaptcha_failed": True}
            
            if "extra_context" in kwargs:
                context.update(kwargs["extra_context"])
            
            return render_to_response("registration/registration_form.html",
                context, context_instance=RequestContext(request))
        
    return register(request, *args, **kwargs)

def check_recaptcha(turing_value,ip):
    '''
    Check recaptcha

    @type turing_value: str
    @param turing_value: turing value in JSON format, should have turing_value["challenge"] and turing_value["response"]
    @type ip: str
    @param ip: IP of client

    @rtype: boolean
    @return: True iff recaptcha pass
    '''
    if force_output != None:
        return force_output
    if not isinstance(turing_value, str):
        return False
    if not isinstance(ip, str):
        return False
    v = json.loads(s=turing_value,encoding="utf8")
    if not isinstance(v, dict):
        return False
    if not isinstance(v["challenge"], unicode):
        return False
    if not isinstance(v["response"], unicode):
        return False
    output = captcha.submit(v["challenge"], v["response"], core_config.RECAPTCHA_PRIVATE_KEY, ip)
    if not output.is_valid:
        return False
    return True

    def clean(self):
        default_error_messages = {
            'captcha_invalid': _(u'Incorrect, please try again.')
        }
        cleaned_data = super(RegistrationFormCaptcha, self).clean()
        remote_ip = cleaned_data.get('remote_ip')
        values = cleaned_data.get('captcha')

        recaptcha_challenge_value = smart_unicode(values[0])
        recaptcha_response_value = smart_unicode(values[1])
        
        try:
            use_ssl = settings.RECAPTCHA_USE_SSL
        except AttributeError:
            use_ssl = False
            
        check_captcha = captcha.submit(recaptcha_challenge_value, 
            recaptcha_response_value, settings.RECAPTCHA_PRIVATE_KEY, remote_ip)

        if not check_captcha.is_valid:
            msg = default_error_messages['captcha_invalid']
            self._errors['captcha'] = self.error_class([msg])
            del cleaned_data['captcha']
            
        return self.cleaned_data