def entry_form(request):
    captcha_error = None
    html_captcha = captcha.displayhtml(settings.RECAPTCHA_PUB_KEY)
    
    if request.method == 'POST':
        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))
        form = EntryForm(request.POST)
        if form.is_valid():
            if not captcha_response.is_valid:
                captcha_error = True
                html_captcha = captcha.displayhtml(settings.RECAPTCHA_PUB_KEY)
                return render_to_response('nest_bizplan/entry_form.html', {'form': form, 'captcha_error': captcha_error, 'html_captcha': html_captcha}, context_instance=RequestContext(request))
            new_entry = form.save()
            
            # Send e-mail to applicant
            subject = 'Education Business Plan Competition - Application Received '
            body = 'Thank you for entering the Milken-PennGSE Education Business Plan Competition! We have received your application. All applications will be reviewed by a panel of judges. Some applicants will then be invited to continue to the next round of the competition, as semi-finalists. We expect that semi-finalists will be announced by January 25, 2011. We will be in touch then - thank you, and best of luck!'
            send_mail(subject, body, settings.DEFAULT_FROM_EMAIL, [new_entry.email])
            
            return HttpResponseRedirect('/business-plan-competition-thanks/')
    else:
        form = EntryForm()
    
    return render_to_response('nest_bizplan/entry_form_closed.html', {'form': form, 'html_captcha': html_captcha}, context_instance=RequestContext(request))

    def process_request(self, req):
        self.check_config()
        action = req.args.get('action')

        if req.method == 'POST' and action == 'create':
            response = captcha.submit(
                req.args['recaptcha_challenge_field'],
                req.args['recaptcha_response_field'],
                self.private_key,
                req.remote_addr,
                )
            if not response.is_valid:
                data = {}
                data['registration_error'] = 'Captcha incorrect. Please try again.'
                data['recaptcha_javascript'] = captcha.displayhtml(self.public_key)
                data['recaptcha_theme'] = self.theme
                return "recaptcharegister.html", data, None
            else:
                ret = super(RecaptchaRegistrationModule, self).process_request(req)
                h, data, n = ret
                data['recaptcha_theme'] = self.theme
                return "recaptcharegister.html", data, n
        else:
            ret = super(RecaptchaRegistrationModule, self).process_request(req)
            h, data, n = ret
            data['recaptcha_javascript'] = captcha.displayhtml(self.public_key)
            data['recaptcha_theme'] = self.theme
            return "recaptcharegister.html", data, n

def webit():
	import os,cgi
	from exceptions import Exception
	from recaptcha.client import captcha
	
	try:
		scriptname=os.environ['SCRIPT_NAME']
	except: 
		raise Exception,'Program should run as a cgi'
	if DEBUG_TO_WEB:
		import cgitb; cgitb.enable()
	
	print 'Content-type: text/html; charset=utf-8\n\n'
	form = cgi.FieldStorage()
	if os.environ['REQUEST_METHOD']=='GET':
		print FORM_PAGE_TEMPLATE % {
			'scriptname':scriptname,
			'errorhtml':'',
			'captcha':captcha.displayhtml(RECAPTCHA_PUBLIC_KEY),
		}
		
	
	
	else: # POST
		errors=[]
		captcha_error=''

		captcha_response = captcha.submit(
			form.getvalue('recaptcha_challenge_field'),
			form.getvalue('recaptcha_response_field'),
			RECAPTCHA_PRIVATE_KEY,
			os.environ['REMOTE_ADDR'])	
		if not captcha_response.is_valid:
			errors.append("You've failed the captcha test. Convince me again that you're not a robot.")
			captcha_error=captcha_response.error_code
		if errors:
			errorhtml='<ul class="error-list">%s</ul>' % ('\n'.join(['<li>%s</li>' % e for e in errors]))
			print FORM_PAGE_TEMPLATE % {
				'scriptname':scriptname,
				'errorhtml':errorhtml,
				'captcha':captcha.displayhtml(RECAPTCHA_PUBLIC_KEY,error=captcha_error),
			}
		else:
			try:
				title = 'Action completed'
				response = 'Thank you.  The form has been submitted to a moderator for review.'
			except Exception,e:
				title = 'Failed'
				response = '<strong>Error:</strong> %s' % str(e)
			print RESPONSE_PAGE_TEMPLATE % {'title':title,'response':response}

def view_form(request, hash, not_active_template = 'tnycnt/tnycnt_not_active.html', 
              form_template = 'tnycnt/tnycnt_mailform.html',
              message_template = 'tnycnt/tnycnt_message.txt',
              ):
    """
    View and send a user created contact form.
    Uses recaptcha lib. If captcha is wrong a message is shown above form.  
    Mail message body can be edit in 'tnycnt/tnycnt_message.txt' and the message
    subject needs TNYCNT_MAIL_SUBJECT in settings file.
    """
    object = get_object_or_404(Contact, hash=hash)
    message = '' 
    if object.is_active == False:
        return render_to_response(not_active_template,
                                  context_instance=RequestContext(request))
    if request.method == 'POST':
        # Captcha check
        check_captcha = captcha.submit(request.POST['recaptcha_challenge_field'],
                        request.POST['recaptcha_response_field'],
                        RECAPTCHA_PRIVATE_KEY,
                        request.META['REMOTE_ADDR'])
        form = ContactMailForm(request.POST)
        html_captcha = captcha.displayhtml(RECAPTCHA_PUB_KEY)
        if check_captcha.is_valid is False:
            #captcha is wrong
            message = _('Captcha failed')
        else:    
            if form.is_valid():
                from django.core.mail import send_mail		
                current_site = Site.objects.get_current()            
                subject = settings.TNYCNT_MAIL_SUBJECT        
                message = render_to_string(message_template,
                                           {'site_name':current_site,
                                            'title':object.title,
                                            'subject':form.cleaned_data['subject'],
                                            'email':form.cleaned_data['email'],
                                            'body': form.cleaned_data['body'] })            
                send_mail(subject, message, settings.DEFAULT_FROM_EMAIL,
                          [object.user.email])
                return HttpResponseRedirect(reverse('tnycnt_sent'))
    else:
        form = ContactMailForm()
        html_captcha = captcha.displayhtml(settings.RECAPTCHA_PUB_KEY)
    return render_to_response(form_template,
                             {'form': form,
                              'html_captcha': html_captcha,
                              'object':object,
                              'message':message},
                              context_instance=RequestContext(request))

def user_creation(request, template_name='registration/create_user.html'):
    "Displays user creation form and handles its action"
    if request.method == "POST":
        if recaptcha is not None:
            if not ('recaptcha_challenge_field' in request.POST
                    and 'recaptcha_response_field' in request.POST
                    and recaptcha.submit(request.POST['recaptcha_challenge_field'],
                                         request.POST['recaptcha_response_field'],
                                         settings.RECAPTCHA_PRIVATE_KEY,
                                         request.remote_addr).is_valid):
                from django.http import HttpResponseForbidden
                return HttpResponseForbidden("invalid captcha")

        form = UserCreationForm(request.POST)
        if form.is_valid():
            form.save()
            # log in the user automatically
            user = authenticate(username=form.cleaned_data["username"],
                                password=form.cleaned_data["password1"])
            perform_login(request, user)
            return redirect("ductus.wiki.views.view_frontpage")
    else:
        form = UserCreationForm()

    captcha_html = ""
    if recaptcha is not None:
        captcha_html = recaptcha.displayhtml(settings.RECAPTCHA_PUBLIC_KEY,
                                             use_ssl=request.is_secure())
        captcha_html = captcha_html.replace('frameborder="0"',
                                            'style="border: 0"')

    return render_to_response(template_name, {
        'form': form,
        'captcha': mark_safe(captcha_html),
    }, context_instance=RequestContext(request))

def problem(request, slug=None):
    show_comments = request.GET.get('show')
    problem = get_object_or_404(Problem, slug=slug)
    form = CommentForm(request.POST or None)
    if request.method == 'POST':
        success = save_comment(request, form, problem)

        # Save name
        if success:
            show_comments = True
            if request.user.is_anonymous():
                form = CommentForm(initial={'name': form.data['name']})

    #Users don't need to pass a captcha
    html_captcha = ''
    if request.user.is_anonymous() and settings.RECAPTCHA_ENABLED:
        html_captcha = captcha.displayhtml(settings.RECAPTCHA_PUBLIC_KEY)
    comment_tree = Comment.objects.select_related('user').filter(problem=problem, spam=False).order_by('path').extra(select={'provider': 'SELECT provider FROM social_auth_usersocialauth WHERE social_auth_usersocialauth.user_id = core_comment.user_id'})

    return render(request, 'core/home.html', {'problem': problem,
                                              'comment_tree': comment_tree,
                                              'form': form,
                                              'html_captcha': html_captcha,
                                              'request': request,
                                              'show_comments': show_comments})

def add():
    if request.method == 'GET':
        template = templates.get_template("add.html")
        return template.render(captcha_html=recaptcha.displayhtml(RECAPTCHA_PUBLIC_KEY))
    elif request.method == 'POST':
        # validate captcha
        recaptcha_response = recaptcha.submit(request.form['recaptcha_challenge_field'], request.form['recaptcha_response_field'], RECAPTCHA_PRIVATE_KEY, request.remote_addr)
        if not recaptcha_response.is_valid:
            template = templates.get_template("recaptcha_failed.html")
            return template.render()

        time_start = time.strptime("%s %s" % (request.form['date'], request.form['time']), '%A %d %B, %Y %H:%M')
        time_start = datetime.datetime.fromtimestamp(time.mktime(time_start))
        venue = request.form['venue']
        artists = [artist for artist in request.form.getlist('artists')if artist]
        gigname = request.form['gigname']
        gigdesc = request.form['gigdesc']
        if not venue or not artists:
            abort(400)

        if not model.get_venue_by_name(venue):
            model.add_venue(venue)
        venue_id = model.get_venue_by_name(venue).id
        for artist in artists:
            if not model.get_artist_by_name(artist):
                model.add_artist(artist)
        artist_ids = [model.get_artist_by_name(artist).id for artist in artists]
        gig_id = model.add_gig(time_start, venue_id, artist_ids, name=gigname, description = gigdesc)

        return redirect('/gig/%s' % gig_id)
    else: # unknown request method
        assert False

def contactForm(request):
    """Contact Form"""
    title = _('Contact')
    message = ''

    if request.method == 'POST':
        form = ContactForm(request.POST)
        if form.is_valid():
            name = form.cleaned_data['name']
            email = form.cleaned_data['email']
            contact_text = form.cleaned_data['contact_text']
            check_captcha = captcha.submit(request.POST['recaptcha_challenge_field'], request.POST['recaptcha_response_field'], RECAPTCHA_PRIVATE_KEY, request.META['REMOTE_ADDR'])
            if check_captcha.is_valid is False:
                # Captcha is wrong show a error ...
                message = _('Error with captcha number. Copy the same number.')
            else:
                subject = _('Contact - %(name)s') % {'name':SITE_TITLE}
                body = _('This email is generated with Contact Module from %(site)s\n\n%(name)s - %(email)s\n%(message)s') % {'site':SITE_TITLE,'name':name,'email':email,'message':contact_text}

                email = EmailMessage(subject, body, to=CONTACT_EMAIL)
                email.send()

                message = _('Thanks for your message. We will respond soon.')
        else:
            message = _('Sorry! This form is not valid. Try again.')

    html_captcha = captcha.displayhtml(RECAPTCHA_PUB_KEY)

    return render_to_response("contact/form.html", locals(), context_instance=RequestContext(request))

    def get(self, idr=None):
        try:
            r = Request.get_by_id(int(idr))
        except:
            r = None

        if r:  # request exists
            chtml = captcha.displayhtml(public_key=RECAPTCHA_PUBLIC_KEY, use_ssl=False, error=None)
            template_values = {
                "title": "Request " + str(r.key().id()),
                "title2": "Modifying request",
                "description": r.description,
                "onload": "document.request.e_pass.focus()",
                "request": r,
                "comments": r.get_comments(),
                "captcha": chtml,
                "admin": users.is_current_user_admin(),
                "logout": users.create_logout_url("/"),
                "lang": self.get_lang(),
            }
            path = os.path.join(os.path.dirname(__file__), "templates/modify_request.html")
            self.response.out.write(template.render(path, template_values))
        elif idr:  # request selected but not found
            self.redirect("/error/404")
        else:  # no request selected
            self.redirect("/new")

 def render(self, name, value, attrs=None):
     use_ssl = False
     if 'RECAPTCHA_USE_SSL' in settings.__members__:
         use_ssl = settings.RECAPTCHA_USE_SSL
     return mark_safe(u'%s' %
                      captcha.displayhtml(settings.RECAPTCHA_PUBLIC_KEY,
                                          use_ssl=use_ssl))

 def change_password(self, check):
     """ """
     user = check_verify_remember(check)
     if user:
         g.chtml = ''
         chtml = captcha.displayhtml(
           public_key = "6Ldph8cSAAAAAGJK1OCZwgqWxctr6gS2FTCM3B1r",
           use_ssl = False,
           error = None)
         g.chtml = Markup(chtml)
         g.check = check
         if request.method == 'POST':
             valid = self.recaptcha()
             if valid:
                 new_password = request.form['new_password'] 
                 new_password_two = request.form['new_password_two'] 
                 if len(new_password) < 6:
                     message = g.users_msg('error_password_1')
                     status = 'msg msg-error'
                 elif new_password != new_password_two:
                     message = g.users_msg('error_password_2')
                     status = 'msg msg-error'
                 else:
                     g.db.users.update({"_id": user['_id']}, {"$set": { "password": create_password(new_password) } })
                     message = g.users_msg('success_update_password')
                     status = 'msg msg-success'
             else:
                 message = g.login_msg('captcha_error')
                 status = 'msg msg-error'
         return render_template('{}/change_password.html'.format(MODULE_DIR), **locals())
     else:
         message = g.login_msg('not_change_password')
         status = 'msg msg-error'
         return render_template('{}/verify.html'.format(MODULE_DIR), **locals())

 def render(self, *args, **kwargs):
     from recaptcha.client import captcha as recaptcha
     custom_translations_str = ''
     if self.custom_translations:
         custom_translations_str = 'custom_translations : {\n'
         for key, value in self.custom_translations.items():
             custom_translations_str += '\n%s: "%s",' % (key, force_unicode(value))
         custom_translations_str = custom_translations_str[:-1]  # Remove the last comma
         custom_translations_str += '},'
     recaptcha_options = """
     <script>
         var RecaptchaOptions = {
             theme: '%s',
             lang: '%s',
             %s
             custom_theme_widget: '%s'
         };
     </script>
     """ % (
         self.theme,
         get_language()[0:2],
         custom_translations_str,
         'recaptcha_widget' if self.theme == 'custom' else ''
         )
     return mark_safe(recaptcha_options + recaptcha.displayhtml(self.public_key))

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 get(self):
     Pagina.get(self)
     # el captcha
     if users.get_current_user():
         chtml = ""
     else:
         chtml = captcha.displayhtml(public_key=RECAPTCHA_PUBLIC_KEY, use_ssl=False, error=None)
     if self.request.get("tipo") == "pregunta":
         foco = "pregunta"
     elif self.request.get("tipo") == "enlace":
         foco = "enlace"
     else:
         foco = "pensamiento"
     template_values = {
         "titulo": "Publicar...",
         "descripcion": u"Formulario de publicación de Ubuntu FAQ. " + APP_DESCRIPTION,
         "tags": "ubuntu, kubuntu, xubuntu, lubuntu, problema, ayuda, linux, karmic, lucid, maverick, natty, ocelot",
         "url": self.url,
         "url_linktext": self.url_linktext,
         "mi_perfil": self.mi_perfil,
         "usuario": users.get_current_user(),
         "notis": self.get_notificaciones(),
         "formulario": self.formulario,
         "error_dominio": self.error_dominio,
         "captcha": chtml,
         "tipo": self.request.get("tipo"),
         "contenido": self.request.get("contenido"),
         "url2": self.request.get("url"),
         "foco": foco,
     }
     path = os.path.join(os.path.dirname(__file__), "templates/nueva.html")
     self.response.out.write(template.render(path, template_values))

    def displayhtml(self, use_ssl=False, error=None):
        """Return HTML string for inserting recaptcha into a form."""
	if not self._initialized:
		self._configure()

        from recaptcha.client.captcha import displayhtml
        return literal(displayhtml(self._public_key, use_ssl = use_ssl, error = error))

 def render(self, *args, **kwargs):
     from recaptcha.client import captcha as recaptcha
     recaptcha_options = u"<script> var RecaptchaOptions = { theme: '" + self.theme + \
                         "', lang: '" + get_language()[0:2] + \
                         ("', custom_theme_widget: 'recaptcha_widget'" if self.theme == 'custom' else "'") + " }; </script>\n"
     return mark_safe(recaptcha_options + recaptcha.displayhtml(
         self.public_key, use_ssl=self.use_ssl))

  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 get_context_data(self, **kwargs):
     context_data = super(CBIReservationView, self).get_context_data(**kwargs)
     context_data['recaptcha_html'] = captcha.displayhtml(settings.RECAPTCHA_PUBLIC_KEY)
     reservation = CBIReservation()
     reservation.product = self._product()
     context_data['object'] = reservation
     return context_data

 def render_editor(self, preview=None, captcha_error=None):
     _ = self.wiki.gettext
     author = self.request.get_author()
     if self.title in self.storage:
         comment = _(u'changed')
         (rev, old_date, old_author,
             old_comment) = self.storage.page_meta(self.title)
         if old_author == author:
             comment = old_comment
     else:
         comment = _(u'uploaded')
         rev = -1
     if captcha and self.wiki.recaptcha_public_key:
         recaptcha_html = captcha.displayhtml(
                 self.wiki.recaptcha_public_key, error=captcha_error)
     else:
         recaptcha_html = None
     context = {
         'comment': comment,
         'author': author,
         'parent': rev,
         'recaptcha_html': recaptcha_html,
         'help': self.get_edit_help(),
     }
     return self.template('edit_file.html', **context)

    def form(self, template=CAPTCHA_TMPL):
        """returns the captcha form"""
        if not self.use:
            return ""

        return template % captcha.displayhtml(self.public_key,
                                              use_ssl=self.use_ssl)