def listAllAppLogDir(service, manifest, package, shortDirName, packagePathStr, appLogDirList):
     """ listAllAppLogDir """
     if (len(appLogDirList) < 1):
         c.errorMsg = 'Could not find logDirs config values in config file %s' % (appLogDirList)
         c.errorCode = Errors.LOG_APP_DIR_CONFIG_MISSING
         return render('/derived/error.html')
     
     for fileName in appLogDirList:
         if (not os.path.exists(os.path.join(packagePathStr, fileName))):
             c.errorMsg = 'App Log directory (%s) missing' % (fileName)
             c.errorCode = Errors.LOG_APP_DIR_NOT_FOUND
             return render('/derived/error.html')
     
     if (request.environ['CONTENT_TYPE'] == 'application/json'):
         return ApplogController.doJSonStr(appLogDirList)
     
     else:
         fullLogList = []
         for fileName in appLogDirList:
             logList = ApplogController.getAppLogEntryHtml(
                         service, manifest, package, shortDirName, packagePathStr, fileName)
             fullLogList.append(logList)
         
         c.status = fullLogList
         c.message = "List Of Files/Directories"
         c.absolutePath = packagePathStr
         c.menuTab = 'MENU_TAB_APPLOGS'
         
         return render('/derived/appLogDirectory.html')

    def login(self):
        '''
        This is the redirect of the first template
        '''
        param = request.params

        c.defaultRealm = getDefaultRealm()
        c.p = {}
        c.user = ""
        c.title = "LinOTP OpenID Service"

        for k in param:
            c.p[k] = param[k]
            if "openid.claimed_id" == k:
                c.user = param[k].rsplit("/", 1)[1]

        ## if we have already a cookie but
        ## a difference between login and cookie user
        ## we show (via  /status) that he is already logged in
        ## and that he first must log out
        cookie = request.cookies.get(COOKIE_NAME)
        if cookie is not None:
            cookie_user, token = cookie.split(":")

            if cookie_user != c.user:
                c.login = cookie_user
                c.message = ("Before logging in as >%s< you have to log out."
                             % (c.user))

                return render("/openid/status.mako")

        return render('/openid/login.mako')

    def doManifestLogFile(action):
        """ do manifest log file """
        service = request.params.get('service', '')
        package = request.params.get('package', '')
        manifest = request.params.get('manifest', 'active')

        if (service == '' or package == ''):
            c.errorMsg = 'missing service or package parameter from request'
            c.errorCode = Errors.LOG_PARAM_REQUIRED
            return render('/derived/error.html')
        print 'service/package/manifest ', service, package, manifest
        packagePathStr = packagePath(service, package, manifest)
        print 'package path ', packagePathStr
        pkgInit = PkgInitConfig(service, package, manifest)
        pkgConfig = pkgInit.getConfigs()
        if not pkgConfig:
            c.errorMsg = 'cronus.ini does not exist, view log needs cronus.ini to know log location, please check your cronus package to make sure cronus.ini exist and have property logAppDir'
            c.errorCode = Errors.CRONUS_INI_EMPTY_NOT_FOUND
            return render('/derived/error.html')
        print '*** packageConfig ', pkgConfig
        manifestFileName = pkgConfig['logManifestFile']
        if (action == 'download'):
            return downloadFile(os.path.join(packagePathStr, manifestFileName))
        if (action == 'tail'):
            lines = request.params.get('size', '100')
            return tailFile(os.path.join(packagePathStr, manifestFileName), lines)
        if (action == 'list'):
            return manifestFileName

    def listAppLogDir(service, manifest, package, shortDirName, dirName):
        """ listAppLogDir """
        LOG.debug('In ApplogController dirName ' + dirName)
        contentType = request.environ['CONTENT_TYPE']
        if (not os.path.exists(dirName)):
            c.errorMsg = 'App Log directory (%s) missing' % (dirName)
            c.errorCode = Errors.LOG_APP_DIR_NOT_FOUND
            return render('/derived/error.html')

        if (os.path.isfile(dirName)):
            if contentType == 'text/plain':
                return downloadFile(dirName)
            else:
                return viewFile(dirName)
        
        if (os.path.isdir(dirName)):
            logList = os.listdir(dirName)
            if contentType == 'application/json':
                return ApplogController.doJSonStr(logList)
            else:
                fullLogList = []
                for fileName in logList:
                    logList = ApplogController.getAppLogEntryHtml(
                                    service, manifest, package, shortDirName, dirName, fileName)
                    fullLogList.append(logList)
                
                c.status = fullLogList
                c.message = "List Of Files/Directories" + ""
                c.absolutePath = dirName
                c.menuTab = 'MENU_TAB_APPLOGS'

                return render('/derived/appLogDirectory.html')

    def cache_content(self, key, do_work, template):
        """Argh!

        Okay, so.  Use this when you want to cache the BODY of a page but not
        the CHROME (i.e., wrapper or base or whatever).

        ``key``
            The key that uniquely identifies this particular rendering of this
            page content.

        ``do_work``
            Some function that will stuff a bunch of expensive data in c.  This
            will only be called if the page hasn't yet been cached.  It'll be
            passed the key.

        ``template``
            Name of the template to use.

        Also, DO NOT FORGET TO wrap the cachable part of your template in a
        <%lib:cache_content> tag, or nothing will get cached!

        If a page body is pulled from cache, c.timer.from_cache will be set to
        True.  If the page had to be generated, it will be set to False.  (If
        this function wasn't involved at all, it will be set to None.)
        """

        # Content needs to be cached per-language
        key = u"{0}/{1}".format(key, c.lang)

        # Cache for...  ten hours?  Sure, whatever
        content_cache = cache.get_cache("content_cache:" + template, expiretime=36000)

        # XXX This is dumb.  Caches don't actually respect the 'enabled'
        # setting, so we gotta fake it.
        if not content_cache.nsargs.get("enabled", True):

            def skip_cache(context, mako_def):
                do_work(key)
                mako_def.body()

            c._cache_me = skip_cache
            return render(template)

        # These pages can be pretty big.  In the case of e.g. memcached, that's
        # a lot of RAM spent on giant pages that consist half of whitespace.
        # Solution: gzip everything.  Use level 1 for speed!
        def cache_me(context, mako_def):
            c.timer.from_cache = True

            def generate_page():
                c.timer.from_cache = False
                do_work(key)
                return zlib.compress(capture(context, mako_def.body).encode("utf8"), 1)

            context.write(zlib.decompress(content_cache.get_value(key=key, createfunc=generate_page)).decode("utf8"))

        c._cache_me = cache_me

        return render(template)

def add_dynamic_selfservice_enrollment(config, actions):
    '''
        add_dynamic_actions - load the html of the dynamic tokens
            according to the policy definition

        :param actions: the allowd policy actions for the current scope
        :type  actions: array of actions names

        :return: hash of {tokentype : html for tab}
    '''

    dynanmic_actions = {}
    g = config['pylons.app_globals']
    tokenclasses = g.tokenclasses

    for tok in tokenclasses.keys():
        tclass = tokenclasses.get(tok)
        tclass_object = newToken(tclass)
        if hasattr(tclass_object, 'getClassInfo'):

            try:
                selfservice = tclass_object.getClassInfo('selfservice', ret=None)
                # # check if we have a policy in the token definition for the enroll
                if selfservice.has_key('enroll') and 'enroll' + tok.upper() in actions:
                    service = selfservice.get('enroll')
                    tab = service.get('title')
                    c.scope = tab.get('scope')
                    t_file = tab.get('html')
                    t_html = render(t_file)
                    ''' remove empty lines '''
                    t_html = '\n'.join([line for line in t_html.split('\n') if line.strip() != ''])
                    e_name = "%s.%s.%s" % (tok, 'selfservice', 'enroll')
                    dynanmic_actions[e_name] = t_html

                # # check if there are other selfserive policy actions
                policy = tclass_object.getClassInfo('policy', ret=None)
                if 'selfservice' in policy:
                    selfserv_policies = policy.get('selfservice').keys()
                    for action in actions:
                        if action in selfserv_policies:
                            # # now lookup, if there is an additional section
                            # # in the selfservice to render
                            service = selfservice.get(action)
                            tab = service.get('title')
                            c.scope = tab.get('scope')
                            t_file = tab.get('html')
                            t_html = render(t_file)
                            ''' remove empty lines '''
                            t_html = '\n'.join([line for line in t_html.split('\n') if line.strip() != ''])
                            e_name = "%s.%s.%s" % (tok, 'selfservice', action)
                            dynanmic_actions[e_name] = t_html


            except Exception as e:
                log.info('[_add_dynamic_actions] no policy for tokentype '
                         '%s found (%r)' % (unicode(tok), e))

    return dynanmic_actions

def add_dynamic_selfservice_enrollment(config, actions):
    """
        add_dynamic_actions - load the html of the dynamic tokens
            according to the policy definition

        :param actions: the allowd policy actions for the current scope
        :type  actions: array of actions names

        :return: hash of {tokentype : html for tab}
    """

    dynanmic_actions = {}
    g = config["pylons.app_globals"]
    tokenclasses = g.tokenclasses

    for tok in tokenclasses.keys():
        tclass = tokenclasses.get(tok)
        tclass_object = newToken(tclass)
        if hasattr(tclass_object, "getClassInfo"):

            try:
                selfservice = tclass_object.getClassInfo("selfservice", ret=None)
                # # check if we have a policy in the token definition for the enroll
                if selfservice.has_key("enroll") and "enroll" + tok.upper() in actions:
                    service = selfservice.get("enroll")
                    tab = service.get("title")
                    c.scope = tab.get("scope")
                    t_file = tab.get("html")
                    t_html = render(t_file)
                    """ remove empty lines """
                    t_html = "\n".join([line for line in t_html.split("\n") if line.strip() != ""])
                    e_name = "%s.%s.%s" % (tok, "selfservice", "enroll")
                    dynanmic_actions[e_name] = t_html

                # # check if there are other selfserive policy actions
                policy = tclass_object.getClassInfo("policy", ret=None)
                if "selfservice" in policy:
                    selfserv_policies = policy.get("selfservice").keys()
                    for action in actions:
                        if action in selfserv_policies:
                            # # now lookup, if there is an additional section
                            # # in the selfservice to render
                            service = selfservice.get(action)
                            tab = service.get("title")
                            c.scope = tab.get("scope")
                            t_file = tab.get("html")
                            t_html = render(t_file)
                            """ remove empty lines """
                            t_html = "\n".join([line for line in t_html.split("\n") if line.strip() != ""])
                            e_name = "%s.%s.%s" % (tok, "selfservice", action)
                            dynanmic_actions[e_name] = t_html

            except Exception as e:
                log.info("[_add_dynamic_actions] no policy for tokentype " "%s found (%r)" % (unicode(tok), e))

    return dynanmic_actions

def _getTokenTypeConfig(section='config'):
    '''
        _getTokenTypeConfig - retrieve from the dynamic token the
                            tokentype section, eg. config or enroll

        :param section: the section of the tokentypeconfig
        :type  section: string

        :return: dict with tab and page definition (rendered)
        :rtype:  dict
    '''

    res = {}
    g = config['pylons.app_globals']
    tokenclasses = g.tokenclasses

    for tok in tokenclasses.keys():
        tclass = tokenclasses.get(tok)
        tclass_object = newToken(tclass)
        if hasattr(tclass_object, 'getClassInfo'):

            conf = tclass_object.getClassInfo(section, ret={})

            ## set globale render scope, so that the mako
            ## renderer will return only a subsection from the template
            p_html = ''
            t_html = ''
            try:
                page = conf.get('page')
                c.scope = page.get('scope')
                p_html = render(os.path.sep + page.get('html'))
                p_html = remove_empty_lines(p_html)


                tab = conf.get('title')
                c.scope = tab.get('scope')
                t_html = render(os.path.sep + tab.get('html'))
                t_html = remove_empty_lines(t_html)

            except CompileException as ex:
                log.error("[_getTokenTypeConfig] compile error while processing %r.%r:" % (tok, section))
                log.error("[_getTokenTypeConfig] %r" % ex)
                log.error("[_getTokenTypeConfig] %s" % traceback.format_exc())
                raise Exception(ex)

            except Exception as e:
                log.debug('no config for token type %r (%r)' % (tok, e))
                p_html = ''

            if len (p_html) > 0:
                res[tok] = { 'html' : p_html, 'title' : t_html}

    return res

def _getTokenTypeConfig(section="config"):
    """
        _getTokenTypeConfig - retrieve from the dynamic token the
                            tokentype section, eg. config or enroll

        :param section: the section of the tokentypeconfig
        :type  section: string

        :return: dict with tab and page definition (rendered)
        :rtype:  dict
    """

    res = {}
    g = config["pylons.app_globals"]
    tokenclasses = g.tokenclasses

    for tok in tokenclasses.keys():
        tclass = tokenclasses.get(tok)
        tclass_object = newToken(tclass)
        if hasattr(tclass_object, "getClassInfo"):

            conf = tclass_object.getClassInfo(section, ret={})

            ## set globale render scope, so that the mako
            ## renderer will return only a subsection from the template
            p_html = ""
            t_html = ""
            try:
                page = conf.get("page")
                c.scope = page.get("scope")
                p_html = render(os.path.sep + page.get("html"))
                p_html = remove_empty_lines(p_html)

                tab = conf.get("title")
                c.scope = tab.get("scope")
                t_html = render(os.path.sep + tab.get("html"))
                t_html = remove_empty_lines(t_html)

            except CompileException as ex:
                log.exception("[_getTokenTypeConfig] compile error while processing %r.%r:" % (tok, section))
                log.error("[_getTokenTypeConfig] %r" % ex)
                raise Exception(ex)

            except Exception as e:
                log.debug("no config for token type %r (%r)" % (tok, e))
                p_html = ""

            if len(p_html) > 0:
                res[tok] = {"html": p_html, "title": t_html}

    return res

    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', ''))
        code = resp.status_int
        if code == 404:
            return render('/404.mako')
        elif code == 500:
            return render('/500.mako')

        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 page

 def render(self, **kwargs):
     '''Override FormAlchemy rendering to use a Ckan template'''
     if hasattr(self, 'form_template') and self.form_template is not None:
         c.fieldset = self
         return render(self.form_template)
     else:
         return formalchemy.FieldSet.render(self, **kwargs)

 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 login(self):
        log.debug("[login] selfservice login screen")
        identity = request.environ.get('repoze.who.identity')
        if identity is not None:
            # After login We always redirect to the start page
            redirect("/")

        res = {}
        try:
            c.defaultRealm = getDefaultRealm()
            res = getRealms()

            c.realmArray = []
            #log.debug("[login] %s" % str(res) )
            for (k, v) in res.items():
                c.realmArray.append(k)

            c.realmbox = getRealmBox()
            log.debug("[login] displaying realmbox: %i" % int(c.realmbox))

            Session.commit()
            response.status = '%i Logout from LinOTP selfservice' % LOGIN_CODE
            return render('/selfservice/login.mako')

        except Exception as e:
            log.exception('[login] failed %r' % e)
            Session.rollback()
            return sendError(response, e)

        finally:
            Session.close()

    def get_my_apps(self):
        """
        Returns the list of registered apps
        """
        user = pylons.request.environ['fts3.User.Credentials']
        my_apps = Session.query(OAuth2Application).filter(OAuth2Application.owner == user.user_dn).all()

        authorized_apps = Session.query(
            OAuth2Application.client_id, OAuth2Application.name, OAuth2Application.website,
            OAuth2Application.description, OAuth2Token.refresh_token, OAuth2Token.scope, OAuth2Token.expires
        ).filter((OAuth2Token.dlg_id == user.delegation_id) & (OAuth2Token.client_id == OAuth2Application.client_id))

        response = {'apps': my_apps, 'authorized': authorized_apps}
        if _accept_html(pylons.request.accept):
            pylons.response.headers['Content-Type'] = 'text/html; charset=UTF-8'
            response['user'] = user
            response['site'] = pylons.config['fts3.SiteName']
            return render('/apps.html', extra_vars=response)
        else:
            pylons.response.headers['Content-Type'] = 'application/json'
            # Better serialization for authorized apps
            authorized = list()
            for auth in authorized_apps:
                authorized.append({
                    'name': auth.name,
                    'website': auth.website,
                    'description': auth.description,
                    'scope': auth.scope,
                    'expires': auth.expires
                })
            response['authorized'] = authorized
            return to_json(response)

    def view(self, id):
        """
        The primary view page for an organism
        """
        organism_guid = id

        credentials = m.login("kconragan", "dulcev1da")
        
        query = {
          "*" : None,
          "guid" : '#' + id,
          "type" : "/user/kconragan/scuba_diving/marine_creature",
          "/common/topic/article" : [{}],
          "/common/topic/image" : [{}]
        }
        
        
        c.content = m.read(query, credentials)
        
        related_query = [{
            "higher_classification" : c.content['higher_classification'],
            "name" : [],
            "guid" : None,
            "type" : "/biology/organism_classification"
        }]
        
        c.related = m.read(related_query, credentials)
        return render('/derived/organism/view.html')

    def wrapped_f(*args, **kwargs):
        result = f(*args, **kwargs)

        extra_vars = {
            # Steal a page from TurboGears' book:
            # include the genshi XML helper for convenience in templates.
            'XML': XML
        }
        extra_vars.update(result)

        # If the provided template path isn't absolute (ie, doesn't start with
        # a '/'), then prepend the default search path. By providing the
        # template path to genshi as an absolute path, we invoke different
        # rules for the resolution of 'xi:include' paths in the template.
        # See http://genshi.edgewall.org/browser/trunk/genshi/template/loader.py#L178
        if not template.startswith('/'):
            tmpl = os.path.join(config['genshi_search_path'], template)
        else:
            tmpl = template

        if request.environ.get('paste.testing', False):
            # Make the vars passed from action to template accessible to tests
            request.environ['paste.testing_variables']['tmpl_vars'] = result

            # Serve application/xhtml+xml instead of text/html during testing.
            # This allows us to query the response xhtml as ElementTree XML
            # instead of BeautifulSoup HTML.
            # NOTE: We do not serve true xhtml to all clients that support it
            #       because of a bug in Mootools Swiff as of v1.2.4:
            #       https://mootools.lighthouseapp.com/projects/2706/tickets/758
            if response.content_type == 'text/html':
                response.content_type = 'application/xhtml+xml'

        return render(tmpl, extra_vars=extra_vars)

 def tokenview(self):
     '''
     This is the template for the token TAB
     '''
     c.title = "privacyIDEA Management"
     c.tokenArray = []
     return render('/manage/tokenview.mako')

 def index(self):
     '''
     This is the redirect to the first template
     '''
     c.title = "LinOTP Self Service"
     ren = render('/selfservice/base.mako')
     return ren

 def setmpin(self):
     '''
     In this form the user my set the PIN for his mOTP application soft
     token on his phone. This is the pin, he needs to enter on his phone,
     before a otp value will be generated.
     '''
     return render('/selfservice/setmpin.mako')

    def tokeninfo(self):
        """
        this returns the contents of /admin/show?serial=xyz in a html format
        """
        param = request.params

        try:
            serial = getParam(param, "serial", required)

            filterRealm = ""
            # check admin authorization
            res = checkPolicyPre("admin", "show", param)

            filterRealm = res["realms"]
            # check if policies are active at all
            # If they are not active, we are allowed to SHOW any tokens.
            pol = getAdminPolicies("show")
            if not pol["active"]:
                filterRealm = ["*"]

            log.info("[tokeninfo] admin >%s< may display the following realms: %s" % (res["admin"], filterRealm))
            log.info("[tokeninfo] displaying tokens: serial: %s", serial)

            toks = TokenIterator(User("", "", ""), serial, filterRealm=filterRealm)

            ### now row by row
            lines = []
            for tok in toks:
                lines.append(tok)
            if len(lines) > 0:

                c.tokeninfo = lines[0]
            else:
                c.tokeninfo = {}

            for k in c.tokeninfo:
                if "LinOtp.TokenInfo" == k:
                    try:
                        # Try to convert string to Dictionary
                        c.tokeninfo["LinOtp.TokenInfo"] = json.loads(c.tokeninfo["LinOtp.TokenInfo"])
                    except:
                        pass

            return render("/manage/tokeninfo.mako")

        except PolicyException as pe:
            log.error("[tokeninfo] Error during checking policies: %r" % pe)
            log.error("[tokeninfo] %s" % traceback.format_exc())
            Session.rollback()
            return sendError(response, unicode(pe), 1)

        except Exception as e:
            log.error("[tokeninfo] failed! %r" % e)
            log.error("[tokeninfo] %s" % traceback.format_exc())
            Session.rollback()
            return sendError(response, e)

        finally:
            Session.close()
            log.debug("[tokeninfo] done")