group_iter = RepoGroupList(_list, perm_set=['group.admin'])

        repo_groups_data = []

        total_records = len(group_iter)

        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup

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

        repo_group_name = lambda repo_group_name, children_groups: (

            template.get_def("repo_group_name")

            .render(repo_group_name, children_groups, _=_, h=h, c=c)

        )

        repo_group_actions = lambda repo_group_id, repo_group_name, gr_count: (

            template.get_def("repo_group_actions")

            .render(repo_group_id, repo_group_name, gr_count, _=_, h=h, c=c,

                    ungettext=ungettext)

        )

        for repo_gr in group_iter:

            children_groups = map(h.safe_unicode,

                itertools.chain((g.name for g in repo_gr.parents),

                                (x.name for x in [repo_gr])))

            repo_count = repo_gr.repositories.count()

            repo_groups_data.append({

                "raw_name": repo_gr.group_name,

                "group_name": repo_group_name(repo_gr.group_name, children_groups),

                "repos": repo_count,

                "owner": h.person(repo_gr.user),

                "action": repo_group_actions(repo_gr.group_id, repo_gr.group_name,

                                             repo_count)

            })

        c.data = json.dumps({

            "totalRecords": total_records,

            "startIndex": 0,

            "sort": None,

            "dir": "asc",

            "records": repo_groups_data

        })

        return render('admin/repo_groups/repo_groups.html')

    def create(self):

        """POST /repo_groups: Create a new item"""

        # url('repos_groups')

        self.__load_defaults()

        # permissions for can create group based on parent_id are checked

        # here in the Form

        # url('users_groups')

        _list = UserGroup.query()\

                        .order_by(func.lower(UserGroup.users_group_name))\

                        .all()

        group_iter = UserGroupList(_list, perm_set=['usergroup.admin'])

        user_groups_data = []

        total_records = len(group_iter)

        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup

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

        user_group_name = lambda user_group_id, user_group_name: (

            template.get_def("user_group_name")

            .render(user_group_id, user_group_name, _=_, h=h, c=c)

        )

        user_group_actions = lambda user_group_id, user_group_name: (

            template.get_def("user_group_actions")

            .render(user_group_id, user_group_name, _=_, h=h, c=c)

        )

        for user_gr in group_iter:

            user_groups_data.append({

                "raw_name": user_gr.users_group_name,

                "group_name": user_group_name(user_gr.users_group_id,

                                              user_gr.users_group_name),

                "members": len(user_gr.members),

                "active": h.boolicon(user_gr.users_group_active),

                "owner": h.person(user_gr.user.username),

                "action": user_group_actions(user_gr.users_group_id, user_gr.users_group_name)

            })

        c.data = json.dumps({

            "totalRecords": total_records,

            "startIndex": 0,

            "sort": None,

            "dir": "asc",

            "records": user_groups_data

        })

        return render('admin/user_groups/user_groups.html')

    @HasPermissionAnyDecorator('hg.admin', 'hg.usergroup.create.true')

    def create(self):

        """POST /users_groups: Create a new item"""

        # url('users_groups')

        users_group_form = UserGroupForm()()

        try:

            form_result = users_group_form.to_python(dict(request.POST))

                        .filter(User.username != User.DEFAULT_USER)\

                        .order_by(func.lower(User.username))\

                        .all()

        users_data = []

        total_records = len(c.users_list)

        _tmpl_lookup = kallithea.CONFIG['pylons.app_globals'].mako_lookup

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

        grav_tmpl = '<div class="gravatar">%s</div>'

        username = lambda user_id, username: (

                template.get_def("user_name")

                .render(user_id, username, _=_, h=h, c=c))

        user_actions = lambda user_id, username: (

                template.get_def("user_actions")

                .render(user_id, username, _=_, h=h, c=c))

        for user in c.users_list:

            users_data.append({

                "gravatar": grav_tmpl % h.gravatar(user.email, size=20),

                "raw_name": user.username,

                "username": username(user.user_id, user.username),

                "last_login": h.fmt_date(user.last_login),

                "last_login_raw": datetime_to_time(user.last_login),

                "active": h.boolicon(user.active),

                "admin": h.boolicon(user.admin),

                "extern_type": user.extern_type,

                "extern_name": user.extern_name,

                "action": user_actions(user.user_id, user.username),

            })

        c.data = json.dumps({

            "totalRecords": total_records,

            "startIndex": 0,

            "sort": None,

            "dir": "asc",

            "records": users_data

        })

        return render('admin/users/users.html')

    def create(self):

        """POST /users: Create a new item"""

        # url('users')

        c.default_extern_type = auth_modules.auth_internal.KallitheaAuthPlugin.name

        user_model = UserModel()

            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 = self._get_user(user)

        repos = AuthUser(user_id=user.user_id).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 = self.sa.query(User).filter(User.active == True).all()

        return json.dumps([

            {

                'id': u.user_id,

                'nname': u.username,

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

                '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) \

            .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):

        def quick_menu(repo_name):

            return _render('quick_menu', repo_name)

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

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

                           short_name=not admin, 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):

            if c.visual.stylify_metatags:

            else:

        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(user_id, username):

            return _render('user_name', user_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 = {

                "menu": quick_menu(repo.repo_name),

                "raw_name": repo.repo_name.lower(),

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

    <div class="title">

        ${self.breadcrumbs()}

    </div>

    <!-- end box / title -->

    <div class="form">

        <div id="summary" class="fields">

            <div class="field">

                <div class="label-summary">

                  <label>${_('Clone URL')}:</label>

                </div>

                <div class="input ${summary(c.show_stats)}">

                  ${self.repotag(c.db_repo)}

                  <input style="width:80%" type="text" id="clone_url" readonly="readonly" value="${c.clone_repo_url}"/>

                  <input style="display:none;width:80%" type="text" id="clone_url_id" readonly="readonly" value="${c.clone_repo_url_id}"/>

                  <div style="display:none" id="clone_by_name" class="btn btn-small">${_('Show by Name')}</div>

                  <div id="clone_by_id" class="btn btn-small">${_('Show by ID')}</div>

                </div>

            </div>

            <div class="field">

              <div class="label-summary">

                  <label>${_('Description')}:</label>

              </div>

                 %if c.visual.stylify_metatags:

                 %else:

                 %endif

            </div>

            <div class="field">

              <div class="label-summary">

                  <label>${_('Trending files')}:</label>

              </div>

              <div class="input ${summary(c.show_stats)}">

                %if c.show_stats:

                <div id="lang_stats"></div>

                %else:

                   ${_('Statistics are disabled for this repository')}

                   %if h.HasPermissionAll('hg.admin')('enable stats on from summary'):

                        ${h.link_to(_('Enable'),h.url('edit_repo',repo_name=c.repo_name, anchor='repo_enable_statistics'),class_="btn btn-mini")}

                   %endif

                %endif

              </div>

            </div>

            <div class="field">

              <div class="label-summary">

                  <label>${_('Download')}:</label>

              </div>

              <div class="input ${summary(c.show_stats)}">