def document(self):
        """Render the error document"""
        request = self._py_object.request
        resp = request.environ.get('pylons.original_response')
        content = literal(resp.body) or cgi.escape(request.GET.get('message', ''))
        c.message = literal(resp.body) or cgi.escape(request.GET.get('message', ''))
        c.code = request.GET.get('code', str(resp.status_int))
        page = error_document_template % \
            dict(prefix=request.environ.get('SCRIPT_NAME', ''),
                 code=cgi.escape(request.GET.get('code', str(resp.status_int))),
                 message=content)

        return render("/errors/error.mako.html")

 def document(self):
     """Render the error document"""
     resp = request.environ.get('pylons.original_response')
     code = cgi.escape(request.GET.get('code', ''))
     content = literal(resp.body) or cgi.escape(request.GET.get('message', ''))
     if resp:
         content = literal(resp.status)
         code = code or cgi.escape(str(resp.status_int))
     if not code:
         raise Exception('No status code was found')
     c.code = code
     c.message = content
     return render('/derived/error/document.html')

    def document(self, filetype='html'):
        resp = request.environ.get('pylons.original_response')
        code = cgi.escape(request.GET.get('code', ''))
        content = cgi.escape(request.GET.get('message', ''))
        if resp:
            content = literal(resp.status)
            code = code or cgi.escape(str(resp.status_int))
        if not code:
            raise Exception('No status code was found')
        
        req = request.environ.get('pylons.original_request')
        routing = req.environ.get('pylons.routes_dict')
        if routing:
            c.controller = routing.get('controller', None)
            c.id = routing.get('id', None)
            c.filetype = routing.get('filetype', 'html')
            c.action = routing.get('action', 'view')
        else:
            c.controller = None
            c.id = None
            c.filetype = 'html'
            c.action = 'view'

        c.code = code
        c.message = content
        return render('error.' + c.filetype)

    def document(self):
        function ='document'
        log.debug(function)

        """Render the error document"""
        resp = request.environ.get('pylons.original_response')
        log.debug('%s resp:%s' % (function, str(resp.status_int)))

        try:
            c.error_number = resp.status_int
            sentto = lca_info['webmaster_email']

            resp = request.environ.get('pylons.original_response')
            c.error_code = cgi.escape(request.GET.get('code', ''))
            content = cgi.escape(request.GET.get('message', ''))
            if resp:
                c.error_message  = literal(resp.status)

            email(sentto, render('error/error_email.mako'))
            return render('/error/%s.mako'%resp.status_int)
        except:

            email(sentto, render('error/error_email.mako'))
            return render('/error/500.mako')

            '''

 def document(self):
     """Render the error document"""
     original_request = request.environ.get('pylons.original_request')
     original_response = request.environ.get('pylons.original_response')
     # When a request (e.g. from a web-bot) is direct, not a redirect
     # from a page. #1176
     if not original_response:
         return 'There is no error.'
     # Bypass error template for API operations.
     if (original_request and
             (original_request.path.startswith('/api') or
              original_request.path.startswith('/fanstatic'))):
         return original_response.body
     # If the charset has been lost on the middleware stack, use the
     # default one (utf-8)
     if not original_response.charset and original_response.default_charset:
         original_response.charset = original_response.default_charset
     # Otherwise, decorate original response with error template.
     content = literal(original_response.unicode_body) or \
         cgi.escape(request.GET.get('message', ''))
     prefix = request.environ.get('SCRIPT_NAME', ''),
     code = cgi.escape(request.GET.get('code',
                       str(original_response.status_int))),
     extra_vars = {'code': code, 'content': content, 'prefix': prefix}
     return render('error_document_template.html', extra_vars=extra_vars)

    def document(self, filetype="html"):
        resp = request.environ.get("pylons.original_response")
        code = cgi.escape(request.GET.get("code", ""))
        content = cgi.escape(request.GET.get("message", ""))
        if resp:
            content = content or resp.body or literal(resp.status)
            code = code or cgi.escape(str(resp.status_int))
        if not code:
            raise Exception("No status code was found")

        req = request.environ.get("pylons.original_request")
        routing = req.environ.get("pylons.routes_dict")
        if routing:
            c.controller = routing.get("controller", None)
            c.id = routing.get("id", None)
            c.filetype = routing.get("filetype", "html")
            c.action = routing.get("action", "view")
        else:
            c.controller = None
            c.id = None
            c.filetype = "html"
            c.action = "view"

        c.code = code
        c.message = content
        return render("error." + c.filetype)

 def url(self, name, value=None, id=None, **attrs):
     kw = {'type': 'text', 'maxlength': 150, 'class_': 'url'}
     kw.update(attrs)
     value = self.value(name, value)
     if value and value.startswith('http://'):
         value = value[len('http://'):]
     return literal(u'http://') + tags.text(name, value, id, **kw)

    def document(self):
        """Render the error document"""

        resp = request.environ.get("pylons.original_response")
        c.message = literal(resp.status)

        return render("/error.html")

    def userInfo(self):
        checkLogIn(session)

        c.site = "Projects"
        c.name = session['user_id']
        c.menu = genMenu(self)

        res = getUserData(c.name)

        c.lineData = [("Username", res[0]), ("Name", res[1]),
                ("Last name", res[2]), ("Email", res[3])]

        c.content = render("/line_by_line.html") + html.literal("<br />")

        c.header = ["All my projects"]

        proj = userProjects(c.name)

        c.rows = []
        for x in proj:
            url_old = urlparse(request.url)
            url = url_old.scheme +'://' + url_old.netloc + getProjectUrl(x[0])
            c.rows.append((link_to(x[0], url),))

        c.style = "width:70%; text-align: left" #XXX: move css to templates

        c.content += render("/table.html")

        return render("/temp.html")

    def document(self):
        """Render the error document - show custom template for 404"""
        self._disable_cache()
        resp = request.environ.get('pylons.original_response')

        # Don't do fancy error documents for JSON
        if resp.headers['Content-Type'] in ['text/javascript', 'application/json', 'text/csv']:
            response.headers['Content-Type'] = resp.headers['Content-Type']
            return resp.body

        code = cgi.escape(request.GET.get('code', str(resp.status_int)))
        content = (literal(resp.body) or
                   cgi.escape(request.GET.get('message', '')))

        if code in self.rendered_error_codes:
            c.code = code
            message = content
            message = message.split('</h1>', 1)[-1]
            message = message.split('</body>', 1)[0]
            c.message = message.split('\n', 2)[-1]
            return render('../templates/%s.html' % code)
        else:
            page = error_document_template % \
                dict(prefix=request.environ.get('SCRIPT_NAME', ''),
                     code=code,
                     message=content)
            return page

 def document(self):
     """Render the error document"""
     resp = request.environ.get('pylons.original_response')
     code = cgi.escape(request.GET.get('code', ''))
     content = cgi.escape(request.GET.get('message', ''))
     if request.environ.get('REQUEST_URI', '').startswith('/api'):
         response.headers['Content-Type'] = resp.headers['Content-Type']
         return resp.body or literal(resp.status)
     if resp:
         content = literal(resp.status)
         code = code or cgi.escape(str(resp.status_int))
     if not code:
         raise Exception(_('No status code found'))
     c.code = code
     c.message = content
     return self.render('/general/error.html')

 def bulk_actions(self):
     ''''Display bootstrap-styled action links respecting the allow_* properties'''
     bulk_actions = self._bulk_actions()
     if bulk_actions:
         return literal(u'<div class="btn-group">' + ''.join(bulk_actions) + '</div>')
     else:
         return u''

  def document(self):
    """Render the error document"""
    '''
          resp = request.environ.get('pylons.original_response')

    content = ''
    try:
      content = literal(resp.body) or cgi.escape(request.GET.get('message', ''))
    except:
      pass

    c.heading = content

    return render('/unauthorized.mako')
    '''
    request = self._py_object.request
    resp = request.environ.get('pylons.original_response')

    try:
        content = literal(resp.body) or cgi.escape(request.GET.get('message', ''))

        page = error_document_template % \
            dict(prefix=request.environ.get('SCRIPT_NAME', ''),
                 code=cgi.escape(request.GET.get('code', str(resp.status_int))),
                 message=content)
    except:
      # resp can be None !
      # @TODO do log what happened here ... not normal
      redirect(url(controller='profile', action='index'))
      pass

    return page

 def document(self):
     """Render the error document"""
     icode = 404
     code= "404"
     status = "Not Found"
     resp = request.environ.get('pylons.original_response')
     if resp and resp.body:
         content = literal(resp.body)
     else:
         content = request.GET.get('message', '')
         if content:
             content = cgi.escape(content)
     if resp and resp.status_int: 
         icode = resp.status_int
         code = str(resp.status_int)
     elif request.GET.get('code', ''):
         code = request.GET.get('code')
         if code:
             code = cgi.escape(code)
         else:
             code = 404
     if resp and resp.status: 
         status = resp.status
     c.message = request.GET.get('message', '')
     if c.message:
         c.message = cgi.escape(c.message)
     else:
         c.message = content
     accept_list = None
     if 'HTTP_ACCEPT' in request.environ:
         try:
             accept_list = conneg_parse(request.environ['HTTP_ACCEPT'])
         except:
             accept_list= [MT("text", "plain")]
     if not accept_list:
         accept_list= [MT("text", "plain")]
     mimetype = accept_list.pop(0)
     while(mimetype):
         if str(mimetype).lower() in ["text/html", "text/xhtml"]:
             #page = error_document_template % \
             #dict(prefix=request.environ.get('SCRIPT_NAME', ''),
             #    code=code,
             #    message=content)
             #return page
             #c.status = status.replace(c.code, '').strip()
             return render('/error.html')
         elif str(mimetype).lower() in ["text/plain", "application/json"]:
             response.content_type = 'text/plain; charset="UTF-8"'
             response.status_int = icode
             response.status = status
             return content
         try:
             mimetype = accept_list.pop(0)
         except IndexError:
             mimetype = None
     #Whoops nothing satisfies - return text/plain
     response.content_type = 'text/plain; charset="UTF-8"'
     response.status_int = resp.status_int
     response.status = resp.status
     return content

 def document(self):
     """Render the error document"""
     resp = request.environ.get('pylons.original_response')
     content = literal(resp.body) or cgi.escape(request.GET.get('message', ''))
     c.code=cgi.escape(request.GET.get('code', str(resp.status_int)))
     c.message = content
     return render('error/error.mako')

    def show(self):
        """ Removes all status messages (including HTML) and returns them 
            for display.
        """
        context = self.context
        annotations = IAnnotations(context)
        msgs = annotations.get(STATUSMESSAGEKEY,
                                context.cookies.get(STATUSMESSAGEKEY))
        msgs = msgs and adapter._decodeCookieValue(msgs) or []

        html_msgs = annotations.get(HTMLMESSAGEKEY,
                                context.cookies.get(HTMLMESSAGEKEY))
        html_msgs = html_msgs and adapter._decodeCookieValue(html_msgs) or []

        for msg in html_msgs:
            msg.message = literal(sanitize(msg.message, cleaner=msgcleaner, wrap=None))

        value = msgs + html_msgs
        
        # clear the existing cookie entries, except on responses that don't
        # actually render in the browser (really, these shouldn't render
        # anything so we shouldn't get to this message, but some templates
        # are sloppy).
        if self.context.response.getStatus() not in (301, 302, 304):
            context.cookies[STATUSMESSAGEKEY] = None
            context.response.expireCookie(STATUSMESSAGEKEY, path='/')
            annotations[STATUSMESSAGEKEY] = None

            context.cookies[HTMLMESSAGEKEY] = None
            context.response.expireCookie(HTMLMESSAGEKEY, path='/')
            annotations[HTMLMESSAGEKEY] = None
        
        return value

    def test_it(self):
        from webhelpers.html.builder import literal
        project = testing.DummyResource(project_name=u'test-project')
        request = testing.DummyRequest()
        result = self._callFUT(request, project)

        self.assertEqual(result, literal(u'<a href="http://example.com/projects/test-project">test-project</a>'))

 def test_many(self):
     from webhelpers.html.builder import literal
     result = self._callFUT([("/", "HOME"), "Projects"])
     self.assertEqual(result, literal(u'<ul class="breadcrumb">'
         '<li><a href="/">HOME</a><span class="divider">/</span></li>'
         '<li class="active">Projects</li>'
         '</ul>'))

 def actions(self, obj):
     ''''Display bootstrap-styled action links respecting the allow_* properties'''
     actions = self._actions(obj)
     if actions:
         return literal(u'<div class="btn-group" style="width: %dpx;">'
             % (len(actions) * 30) + ''.join(actions) + u'</div>')
     else:
         return u''

def get_i18n_text(text_id):
    from pylons import tmpl_context as c
    text_obj = LanguageText.get(text_id, c.lang)
    if text_obj is None:
        text_obj = LanguageText.get(text_id, 'en')
    if text_obj is None:
        return ''
    return literal(text_obj.text)