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 = self.sa.query(User) \

            .filter(User.active == True) \

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

            .all()

        return json.dumps([

            {

                '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 = self.sa.query(UserGroup) \

            .filter(UserGroup.users_group_active == True) \

            .order_by(UserGroup.users_group_name) \

            .options(subqueryload(UserGroup.members)) \

            .all()

        user_groups = UserGroupList(user_groups, perm_set=['usergroup.read',

                                                           'usergroup.write',

                                                           'usergroup.admin'])

        return json.dumps([

            {

                'id': gr.users_group_id,

                'grname': gr.users_group_name,

                'grmembers': len(gr.members),

            } for gr in user_groups]

        )

    @classmethod

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

        import kallithea

        from pylons import tmpl_context as c

        from pylons.i18n.translation import _

        _tmpl_lookup = kallithea.CONFIG['pylons.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))

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

    def get_repos_as_dict(self, repos_list=None, admin=False, perm_check=True,

                          super_user_actions=False, short_name=False):

        _render = self._render_datatable

        from pylons 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)

        def owner_actions(owner_id, username):

            return _render('user_name', owner_id, username)

        repos_data = []

        for repo in repos_list:

            if perm_check:

                # check permission at this level

                if not HasRepoPermissionAny(

                        'repository.read', 'repository.write',

                        'repository.admin'

                )(repo.repo_name, 'get_repos_as_dict check'):

                    continue

            cs_cache = repo.changeset_cache

            row = {

                "raw_name": repo.repo_name,

                "name": repo_lnk(repo.repo_name, repo.repo_type,

                                 repo.repo_state, repo.private, repo.fork),

                "last_change_iso": repo.last_db_change.isoformat(),

                "last_change": last_change(repo.last_db_change),

                "last_changeset": last_rev(repo.repo_name, cs_cache),

                "last_rev_raw": cs_cache.get('revision'),

                "desc": desc(repo.description),

                "owner": h.person(repo.owner),

                "state": state(repo.repo_state),

                "rss": rss_lnk(repo.repo_name),

                "atom": atom_lnk(repo.repo_name),

            }

            if admin:

                row.update({

                    "action": repo_actions(repo.repo_name),

                    "owner": owner_actions(repo.owner_id,

                                           h.person(repo.owner))

                })

            repos_data.append(row)

        return {

            "totalRecords": len(repos_list),

            "startIndex": 0,

            "sort": "name",

            "dir": "asc",

            "records": repos_data

        }

    def _get_defaults(self, repo_name):

        """

        Gets information about repository, and returns a dict for

        usage in forms

        :param repo_name:

        """

        repo_info = Repository.get_by_repo_name(repo_name)

        if repo_info is None:

            return None

        defaults = repo_info.get_dict()

        defaults['repo_name'] = repo_info.just_name

        defaults['repo_group'] = repo_info.group_id

        for strip, k in [(0, 'repo_type'), (1, 'repo_enable_downloads'),

                         (1, 'repo_description'), (1, 'repo_enable_locking'),

                         (1, 'repo_landing_rev'), (0, 'clone_uri'),

                         (1, 'repo_private'), (1, 'repo_enable_statistics')]:

            attr = k

            if strip:

                attr = remove_prefix(k, 'repo_')

            val = defaults[attr]

            if k == 'repo_landing_rev':

                val = ':'.join(defaults[attr])

            defaults[k] = val

            if k == 'clone_uri':

                defaults['clone_uri_hidden'] = repo_info.clone_uri_hidden

        # fill owner

        if repo_info.owner:

            defaults.update({'owner': repo_info.owner.username})

        else:

            replacement_user = User.query().filter(User.admin ==

                                                   True).first().username

            defaults.update({'owner': replacement_user})

        # fill repository users

        for p in repo_info.repo_to_perm:

            defaults.update({'u_perm_%s' % p.user.username:

                                 p.permission.permission_name})

        # fill repository groups

        for p in repo_info.users_group_to_perm:

            defaults.update({'g_perm_%s' % p.users_group.users_group_name:

                                 p.permission.permission_name})

        return defaults

    def update(self, repo, **kwargs):

        try:

            cur_repo = self._get_repo(repo)

            org_repo_name = cur_repo.repo_name

            if 'owner' in kwargs:

                cur_repo.owner = User.get_by_username(kwargs['owner'])

            if 'repo_group' in kwargs:

                cur_repo.group = RepoGroup.get(kwargs['repo_group'])

                cur_repo.repo_name = cur_repo.get_new_name(cur_repo.just_name)

            log.debug('Updating repo %s with params:%s', cur_repo, kwargs)

            for k in ['repo_enable_downloads',

                      'repo_description',

                      'repo_enable_locking',

                      'repo_landing_rev',

<%page args="parent,group_name=''" />

    <div class="panel panel-primary">

        <div class="panel-heading clearfix">

            <div class="pull-left breadcrumbs">

                %if c.group is not None:

                    %for group in c.group.parents:

                        ${h.link_to(group.name, url('repos_group_home', group_name=group.group_name))}

                        »

                    %endfor

                    ${c.group.group_name}

                %endif

            </div>

            %if c.authuser.username != 'default':

              <ul class="pull-right links">

                <li>

                <%

                    gr_name = c.group.group_name if c.group else None

                    # create repositories with write permission on group is set to true

                    create_on_write = h.HasPermissionAny('hg.create.write_on_repogroup.true')()

                    group_admin = h.HasRepoGroupPermissionAny('group.admin')(gr_name, 'can write into group index page')

                    group_write = h.HasRepoGroupPermissionAny('group.write')(gr_name, 'can write into group index page')

                %>

                %if h.HasPermissionAny('hg.admin','hg.create.repository')() or (group_admin or (group_write and create_on_write)):

                  %if c.group:

                        <a href="${h.url('new_repo',parent_group=c.group.group_id)}" class="btn btn-default btn-xs"><i class="icon-plus"></i> ${_('Add Repository')}</a>

                        %if h.HasPermissionAny('hg.admin')() or h.HasRepoGroupPermissionAny('group.admin')(c.group.group_name):

                            <a href="${h.url('new_repos_group', parent_group=c.group.group_id)}" class="btn btn-default btn-xs"><i class="icon-plus"></i> ${_('Add Repository Group')}</a>

                        %endif

                  %else:

                    <a href="${h.url('new_repo')}" class="btn btn-default btn-xs"><i class="icon-plus"></i> ${_('Add Repository')}</a>

                    %if h.HasPermissionAny('hg.admin')():

                        <a href="${h.url('new_repos_group')}" class="btn btn-default btn-xs"><i class="icon-plus"></i> ${_('Add Repository Group')}</a>

                    %endif

                  %endif

                %endif

                %if c.group and h.HasRepoGroupPermissionAny('group.admin')(c.group.group_name):

                    <a href="${h.url('edit_repo_group',group_name=c.group.group_name)}" title="${_('You have admin right to this group, and can edit it')}" class="btn btn-default btn-xs"><i class="icon-pencil"></i> ${_('Edit Repository Group')}</a>

                %endif

                </li>

              </ul>

            %endif

        </div>

        %if c.groups:

        <div class="panel-body">

              <table id="groups_list" class="table">

                  <thead>

                      <tr>

                          <th class="left">${_('Repository Group')}</th>

                          <th class="left">${_('Description')}</th>

                          ##<th class="left">${_('Number of Repositories')}</th>

                      </tr>

                  </thead>

                  ## REPO GROUPS

                  % for gr in c.groups:

                    <tr>

                        <td>

                            <div class="dt_repo">

                              <a href="${url('repos_group_home',group_name=gr.group_name)}">

                                <i class="icon-folder"></i>

                                <span class="dt_repo_name">${gr.name}</span>

                              </a>

                            </div>

                        </td>

                        <td>${h.urlify_text(gr.group_description, stylize=c.visual.stylify_metatags)}</td>

                        ## this is commented out since for multi nested repos can be HEAVY!

                        ## in number of executed queries during traversing uncomment at will

                        ##<td><b>${gr.repositories_recursive_count}</b></td>

                    </tr>

                  % endfor

              </table>

        </div>

        %endif

        <div class="panel-body">

            <table class="table" id="repos_list_wrap"></table>

        </div>

    </div>

      <script>

        $('#groups_list').DataTable({

            dom: '<"dataTables_left"f><"dataTables_right"ilp>t',

            pageLength: 100

        });

        var data = ${c.data|n},

            $dataTable = $("#repos_list_wrap").DataTable({

                data: data.records,

                columns: [

                    {data: "raw_name", visible: false, searchable: false},

                    {title: "${_('Repository')}", data: "name", orderData: 1, render: {

                        }

                    }},

                    {data: "desc", title: "${_('Description')}", searchable: false},

                    {data: "last_change_iso", visible: false, searchable: false},

                    {data: "last_change", title: "${_('Last Change')}", orderData: 4, searchable: false},

                    {data: "last_rev_raw", visible: false, searchable: false},

                    {data: "last_changeset", title: "${_('Tip')}", orderData: 6, searchable: false},

                    {data: "owner", title: "${_('Owner')}", searchable: false},

                    {data: "atom", sortable: false}

                ],

                order: [[1, "asc"]],

                dom: '<"dataTables_left"f><"dataTables_right"ilp>t',

                pageLength: 100

            });

      </script>