return repo.scalar()

    def get_repo(self, repository):

        return Repository.guess_instance(repository)

    def get_by_repo_name(self, repo_name, cache=False):

        repo = Repository.query() \

            .filter(Repository.repo_name == repo_name)

        if cache:

            repo = repo.options(FromCache("sql_cache_short",

                                          "get_repo_%s" % repo_name))

        return repo.scalar()

    def get_all_user_repos(self, user):

        """

        Gets all repositories that user have at least read access

        :param user:

        """

        from kallithea.lib.auth import AuthUser

        user = User.guess_instance(user)

        repos = AuthUser(dbuser=user).permissions['repositories']

        access_check = lambda r: r[1] in ['repository.read',

                                          'repository.write',

                                          'repository.admin']

        repos = [x[0] for x in filter(access_check, repos.items())]

        return Repository.query().filter(Repository.repo_name.in_(repos))

    def get_users_js(self):

        users = User.query() \

            .filter(User.active == True) \

            .order_by(User.name, User.lastname) \

            .all()

        return [

            {

                'id': u.user_id,

                'fname': h.escape(u.name),

                'lname': h.escape(u.lastname),

                'nname': u.username,

                'gravatar_lnk': h.gravatar_url(u.email, size=28, default='default'),

                'gravatar_size': 14,

            } for u in users]

    def get_user_groups_js(self):

        user_groups = UserGroup.query() \

            .filter(UserGroup.users_group_active == True) \

            .order_by(UserGroup.users_group_name) \

            .all()

        user_groups = UserGroupList(user_groups, perm_level='read')

        return [

            {

                'id': gr.users_group_id,

                'grname': gr.users_group_name,

            } for gr in user_groups]

    @classmethod

    def _render_datatable(cls, tmpl, *args, **kwargs):

        import kallithea

        from tg import tmpl_context as c, request, app_globals

        from tg.i18n import ugettext as _

        _tmpl_lookup = app_globals.mako_lookup

        template = _tmpl_lookup.get_template('data_table/_dt_elements.html')

        tmpl = template.get_def(tmpl)

        kwargs.update(dict(_=_, h=h, c=c, request=request))

        return tmpl.render(*args, **kwargs)

    def get_repos_as_dict(self, repos_list=None, repo_groups_list=None,

                          admin=False, perm_check=True,

                          super_user_actions=False, short_name=False):

        _render = self._render_datatable

        from tg import tmpl_context as c

        def repo_lnk(name, rtype, rstate, private, fork_of):

            return _render('repo_name', name, rtype, rstate, private, fork_of,

                           short_name=short_name, admin=False)

        def last_change(last_change):

            return _render("last_change", last_change)

        def rss_lnk(repo_name):

            return _render("rss", repo_name)

        def atom_lnk(repo_name):

            return _render("atom", repo_name)

        def last_rev(repo_name, cs_cache):

            return _render('revision', repo_name, cs_cache.get('revision'),

                           cs_cache.get('raw_id'), cs_cache.get('author'),

                           cs_cache.get('message'))

        def desc(desc):

            return h.urlify_text(desc, truncate=80, stylize=c.visual.stylify_metatags)

        def state(repo_state):

            return _render("repo_state", repo_state)

        def repo_actions(repo_name):

            return _render('repo_actions', repo_name, super_user_actions)

};

// Highlight the snippet if it is found in the full text.

// Snippet must be lowercased already.

var autocompleteHighlightMatch = function (full, snippet) {

    var matchindex = full.toLowerCase().indexOf(snippet);

    if (matchindex <0)

        return full;

    return full.substring(0, matchindex)

        + '<span class="select2-match">'

        + full.substr(matchindex, snippet.length)

        + '</span>' + full.substring(matchindex + snippet.length);

};

// Return html snippet for showing the provided gravatar url

var gravatar = function(gravatar_lnk, size, cssclass) {

    if (!gravatar_lnk) {

        return '';

    }

    if (gravatar_lnk == 'default') {

        return '<i class="icon-user {1}" style="font-size: {0}px;"></i>'.format(size, cssclass);

    }

    return ('<i class="icon-empty {2}"' +

            ' style="font-size: {0}px;background-image: url(\'{1}\'); background-size: {0}px"' +

            '></i>').format(size, gravatar_lnk, cssclass);

}

var autocompleteGravatar = function(res, gravatar_lnk, size, group) {

    var elem;

    if (group !== undefined) {

        elem = '<i class="perm-gravatar-ac icon-users"></i>';

    } else {

        elem = gravatar(gravatar_lnk, size, "perm-gravatar-ac");

    }

    return '<div class="ac-container-wrap">{0}{1}</div>'.format(elem, res);

}

// Custom formatter to highlight the matching letters

var autocompleteFormatter = function (oResultData, sQuery, sResultMatch) {

    var query;

    if (sQuery && sQuery.toLowerCase) // YAHOO AutoComplete

        query = sQuery.toLowerCase();

    else if (sResultMatch && sResultMatch.term) // select2 - parameter names doesn't match

        query = sResultMatch.term.toLowerCase();

    // group

    if (oResultData.grname) {

        return autocompleteGravatar(

                _TM['Group'],

            null, null, true);

    }

    // users

    if (oResultData.nname) {

        var displayname = autocompleteHighlightMatch(oResultData.nname, query);

        if (oResultData.fname && oResultData.lname) {

            displayname = "{0} {1} ({2})".format(

                autocompleteHighlightMatch(oResultData.fname, query),

                autocompleteHighlightMatch(oResultData.lname, query),

                displayname);

        }

        return autocompleteGravatar(displayname, oResultData.gravatar_lnk, oResultData.gravatar_size);

    }

    return '';

};

// Generate a basic autocomplete instance that can be tweaked further by the caller

var autocompleteCreate = function ($inputElement, matchFunc) {

    var $container = $('<div/>').insertAfter($inputElement);

    var datasource = new YAHOO.util.FunctionDataSource(matchFunc);

    var autocomplete = new YAHOO.widget.AutoComplete($inputElement[0], $container[0], datasource);

    autocomplete.useShadow = false;

    autocomplete.resultTypeList = false;

    autocomplete.animVert = false;

    autocomplete.animHoriz = false;

    autocomplete.animSpeed = 0.1;

    autocomplete.formatResult = autocompleteFormatter;

    return autocomplete;

}

var SimpleUserAutoComplete = function ($inputElement, users_list) {

    $inputElement.select2(

    {

        formatInputTooShort: $inputElement.attr('placeholder'),

        initSelection : function (element, callback) {

            var val = $inputElement.val();

            $.each(users_list, function(i, user) {

                if (user.nname == val)

                    callback(user);

            });

        },

        minimumInputLength: 1,

        query: function (query) {

## -*- coding: utf-8 -*-

<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml">

    <head>

        <title><%block name="title"/><%block name="branding_title"/></title>

        <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />

        <meta name="robots" content="index, nofollow"/>

        <meta name="viewport" content="width=device-width, initial-scale=1.0" />

        <link rel="icon" href="${h.url('/images/favicon.ico')}" type="image/x-icon" />

        ## CSS ###

        <link rel="stylesheet" type="text/css" href="${h.url('/css/jquery.dataTables.css', ver=c.kallithea_version)}"/>

        <link rel="stylesheet" type="text/css" href="${h.url('/js/select2/select2.css', ver=c.kallithea_version)}"/>

        <link rel="stylesheet" type="text/css" href="${h.url('/css/bootstrap.css', ver=c.kallithea_version)}"/>

        <link rel="stylesheet" type="text/css" href="${h.url('/js/select2/select2-bootstrap.css', ver=c.kallithea_version)}"/>

        <link rel="stylesheet" type="text/css" href="${h.url('/css/pygments.css', ver=c.kallithea_version)}"/>

        <link rel="stylesheet" type="text/css" href="${h.url('/css/style.css', ver=c.kallithea_version)}" media="screen"/>

        <link rel="stylesheet" type="text/css" href="${h.url('/css/contextbar.css', ver=c.kallithea_version)}" media="screen"/>

        <link rel="stylesheet" type="text/css" href="${h.url('/fontello/css/kallithea.css', ver=c.kallithea_version)}">

        <%block name="css_extra"/>

        ## JAVASCRIPT ##

        <script type="text/javascript">

            ## JS translations map

            var TRANSLATION_MAP = {

                'Cancel': ${h.jshtml(_("Cancel"))},

                'Retry': ${h.jshtml(_("Retry"))},

                'Submitting ...': ${h.jshtml(_("Submitting ..."))},

                'Unable to post': ${h.jshtml(_("Unable to post"))},

                'Add Another Comment': ${h.jshtml(_("Add Another Comment"))},

                'Stop following this repository': ${h.jshtml(_('Stop following this repository'))},

                'Start following this repository': ${h.jshtml(_('Start following this repository'))},

                'Group': ${h.jshtml(_('Group'))},

                'Loading ...': ${h.jshtml(_('Loading ...'))},

                'loading ...': ${h.jshtml(_('loading ...'))},

                'Search truncated': ${h.jshtml(_('Search truncated'))},

                'No matching files': ${h.jshtml(_('No matching files'))},

                'Open New Pull Request from {0}': ${h.jshtml(_('Open New Pull Request from {0}'))},

                'Open New Pull Request for {0} → {1}': ${h.js(_('Open New Pull Request for {0} → {1}'))},

                'Show Selected Changesets {0} → {1}': ${h.js(_('Show Selected Changesets {0} → {1}'))},

                'Selection Link': ${h.jshtml(_('Selection Link'))},

                'Collapse Diff': ${h.jshtml(_('Collapse Diff'))},

                'Expand Diff': ${h.jshtml(_('Expand Diff'))},

                'Type name of user or member to grant permission': ${h.jshtml(_('Type name of user or member to grant permission'))},

                'Failed to revoke permission': ${h.jshtml(_('Failed to revoke permission'))},

                'Confirm to revoke permission for {0}: {1} ?': ${h.jshtml(_('Confirm to revoke permission for {0}: {1} ?'))},

                'Enabled': ${h.jshtml(_('Enabled'))},

                'Disabled': ${h.jshtml(_('Disabled'))},

                'Select changeset': ${h.jshtml(_('Select changeset'))},

                'Specify changeset': ${h.jshtml(_('Specify changeset'))},

                'MSG_SORTASC': ${h.jshtml(_('Click to sort ascending'))},

                'MSG_SORTDESC': ${h.jshtml(_('Click to sort descending'))},

                'MSG_EMPTY': ${h.jshtml(_('No records found.'))},

                'MSG_ERROR': ${h.jshtml(_('Data error.'))},

                'MSG_LOADING': ${h.jshtml(_('Loading...'))}

            };

            var _TM = TRANSLATION_MAP;

            var TOGGLE_FOLLOW_URL  = ${h.js(h.url('toggle_following'))};

            var REPO_NAME = "";

            %if hasattr(c, 'repo_name'):

                var REPO_NAME = ${h.js(c.repo_name)};

            %endif

            var _authentication_token = ${h.js(h.authentication_token())};

        </script>

        <script type="text/javascript" src="${h.url('/js/yui.2.9.js', ver=c.kallithea_version)}"></script>

        <script type="text/javascript" src="${h.url('/js/jquery.min.js', ver=c.kallithea_version)}"></script>

        <script type="text/javascript" src="${h.url('/js/jquery.dataTables.min.js', ver=c.kallithea_version)}"></script>

        <script type="text/javascript" src="${h.url('/js/bootstrap.js', ver=c.kallithea_version)}"></script>

        <script type="text/javascript" src="${h.url('/js/select2/select2.js', ver=c.kallithea_version)}"></script>

        <script type="text/javascript" src="${h.url('/js/native.history.js', ver=c.kallithea_version)}"></script>

        <script type="text/javascript" src="${h.url('/js/base.js', ver=c.kallithea_version)}"></script>

        ## EXTRA FOR JS

        <%block name="js_extra"/>

        <script type="text/javascript">

            (function(window,undefined){

                var History = window.History; // Note: We are using a capital H instead of a lower h

                if ( !History.enabled ) {

                     // History.js is disabled for this browser.