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

    @NotAnonymous()

    def create(self):

        self.__load_defaults()

        form_result = {}

        try:

            # CanWriteGroup validators checks permissions of this POST

            form_result = RepoForm(repo_groups=c.repo_groups,

                                   landing_revs=c.landing_revs_choices)() \

                            .to_python(dict(request.POST))

            # create is done sometimes async on celery, db transaction

            # management is handled there.

            task = RepoModel().create(form_result, request.authuser.user_id)

            task_id = task.task_id

        except formencode.Invalid as errors:

            log.info(errors)

            return htmlfill.render(

                render('admin/repos/repo_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                force_defaults=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            msg = (_('Error creating repository %s')

                   % form_result.get('repo_name'))

            h.flash(msg, category='error')

            raise HTTPFound(location=url('home'))

        raise HTTPFound(location=h.url('repo_creating_home',

                              repo_name=form_result['repo_name_full'],

                              task_id=task_id))

    @NotAnonymous()

    def create_repository(self):

        self.__load_defaults()

        if not c.repo_groups:

            raise HTTPForbidden

        parent_group = request.GET.get('parent_group')

        ## apply the defaults from defaults page

        defaults = Setting.get_default_repo_settings(strip_prefix=True)

        if parent_group:

            prg = RepoGroup.get(parent_group)

            if prg is None or not any(rgc[0] == prg.group_id

                                      for rgc in c.repo_groups):

                raise HTTPForbidden

            defaults.update({'repo_group': parent_group})

        return htmlfill.render(

            render('admin/repos/repo_add.html'),

            defaults=defaults,

            errors={},

            prefix_error=False,

            encoding="UTF-8",

            force_defaults=False)

    @LoginRequired()

    def repo_creating(self, repo_name):

        c.repo = repo_name

        c.task_id = request.GET.get('task_id')

        if not c.repo:

            raise HTTPNotFound()

        return render('admin/repos/repo_creating.html')

    @LoginRequired()

    @jsonify

    def repo_check(self, repo_name):

        c.repo = repo_name

        task_id = request.GET.get('task_id')

        if task_id and task_id not in ['None']:

            from kallithea import CELERY_ON

            from kallithea.lib import celerypylons

            if CELERY_ON:

                task = celerypylons.result.AsyncResult(task_id)

                if task.failed():

                    raise HTTPInternalServerError(task.traceback)

        repo = Repository.get_by_repo_name(repo_name)

        if repo and repo.repo_state == Repository.STATE_CREATED:

            if repo.clone_uri:

                h.flash(_('Created repository %s from %s')

                        % (repo.repo_name, repo.clone_uri_hidden), category='success')

            else:

                repo_url = h.link_to(repo.repo_name,

                                     h.url('summary_home',

                                           repo_name=repo.repo_name))

                fork = repo.fork

                if fork is not None:

                    fork_name = fork.repo_name

                else:

                            category='success')

            return {'result': True}

        return {'result': False}

    @HasRepoPermissionLevelDecorator('admin')

    def update(self, repo_name):

        c.repo_info = self._load_repo()

        self.__load_defaults(c.repo_info)

        c.active = 'settings'

        c.repo_fields = RepositoryField.query() \

            .filter(RepositoryField.repository == c.repo_info).all()

        repo_model = RepoModel()

        changed_name = repo_name

        repo = Repository.get_by_repo_name(repo_name)

        old_data = {

            'repo_name': repo_name,

            'repo_group': repo.group.get_dict() if repo.group else {},

            'repo_type': repo.repo_type,

        }

        _form = RepoForm(edit=True, old_data=old_data,

                         repo_groups=c.repo_groups,

                         landing_revs=c.landing_revs_choices)()

        try:

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

            repo = repo_model.update(repo_name, **form_result)

            ScmModel().mark_for_invalidation(repo_name)

            h.flash(_('Repository %s updated successfully') % repo_name,

                    category='success')

            changed_name = repo.repo_name

            action_logger(request.authuser, 'admin_updated_repo',

                changed_name, request.ip_addr)

            Session().commit()

        except formencode.Invalid as errors:

            log.info(errors)

            defaults = self.__load_data()

            defaults.update(errors.value)

            return htmlfill.render(

                render('admin/repos/repo_edit.html'),

                defaults=defaults,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during update of repository %s')

                    % repo_name, category='error')

        raise HTTPFound(location=url('edit_repo', repo_name=changed_name))

    @HasRepoPermissionLevelDecorator('admin')

    def delete(self, repo_name):

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.not_mapped_error(repo_name)

            raise HTTPFound(location=url('repos'))

        try:

            _forks = repo.forks.count()

            handle_forks = None

            if _forks and request.POST.get('forks'):

                do = request.POST['forks']

                if do == 'detach_forks':

                    handle_forks = 'detach'

                    h.flash(_('Detached %s forks') % _forks, category='success')

                elif do == 'delete_forks':

                    handle_forks = 'delete'

                    h.flash(_('Deleted %s forks') % _forks, category='success')

            repo_model.delete(repo, forks=handle_forks)

            action_logger(request.authuser, 'admin_deleted_repo',

                repo_name, request.ip_addr)

            ScmModel().mark_for_invalidation(repo_name)

            h.flash(_('Deleted repository %s') % repo_name, category='success')

            Session().commit()

        except AttachedForksError:

            h.flash(_('Cannot delete repository %s which still has forks')

                        % repo_name, category='warning')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

        if repo.group:

            raise HTTPFound(location=url('repos_group_home', group_name=repo.group.group_name))

        raise HTTPFound(location=url('repos'))

    @HasRepoPermissionLevelDecorator('admin')

    def edit(self, repo_name):

        defaults = self.__load_data()

        c.repo_fields = RepositoryField.query() \

            .filter(RepositoryField.repository == c.repo_info).all()

        c.active = 'settings'

        return htmlfill.render(

            if each.ui_section in ['hooks', 'extensions']:

                v = each.ui_active

            settings[k] = v

        return settings

    @HasPermissionAnyDecorator('hg.admin')

    def settings_vcs(self):

        c.active = 'vcs'

        if request.POST:

            application_form = ApplicationUiSettingsForm()()

            try:

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

            except formencode.Invalid as errors:

                return htmlfill.render(

                     render('admin/settings/settings.html'),

                     defaults=errors.value,

                     errors=errors.error_dict or {},

                     prefix_error=False,

                     encoding="UTF-8",

                     force_defaults=False)

            try:

                if c.visual.allow_repo_location_change:

                    sett = Ui.get_by_key('paths', '/')

                    sett.ui_value = form_result['paths_root_path']

                # HOOKS

                sett = Ui.get_by_key('hooks', Ui.HOOK_UPDATE)

                sett.ui_active = form_result['hooks_changegroup_update']

                sett = Ui.get_by_key('hooks', Ui.HOOK_REPO_SIZE)

                sett.ui_active = form_result['hooks_changegroup_repo_size']

                sett = Ui.get_by_key('hooks', Ui.HOOK_PUSH_LOG)

                sett.ui_active = form_result['hooks_changegroup_push_logger']

                sett = Ui.get_by_key('hooks', Ui.HOOK_PULL_LOG)

                sett.ui_active = form_result['hooks_outgoing_pull_logger']

                ## EXTENSIONS

                sett = Ui.get_or_create('extensions', 'largefiles')

                sett.ui_active = form_result['extensions_largefiles']

                sett = Ui.get_or_create('extensions', 'hgsubversion')

                sett.ui_active = form_result['extensions_hgsubversion']

                if sett.ui_active:

                    try:

                        import hgsubversion  # pragma: no cover

                    except ImportError:

                        raise HgsubversionImportError

#                sett = Ui.get_or_create('extensions', 'hggit')

#                sett.ui_active = form_result['extensions_hggit']

                Session().commit()

                h.flash(_('Updated VCS settings'), category='success')

            except HgsubversionImportError:

                log.error(traceback.format_exc())

                h.flash(_('Unable to activate hgsubversion support. '

                          'The "hgsubversion" library is missing'),

                        category='error')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred while updating '

                          'application settings'), category='error')

        defaults = Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

            render('admin/settings/settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasPermissionAnyDecorator('hg.admin')

    def settings_mapping(self):

        c.active = 'mapping'

        if request.POST:

            rm_obsolete = request.POST.get('destroy', False)

            install_git_hooks = request.POST.get('hooks', False)

            overwrite_git_hooks = request.POST.get('hooks_overwrite', False)

            invalidate_cache = request.POST.get('invalidate', False)

            log.debug('rescanning repo location with destroy obsolete=%s, '

                      'install git hooks=%s and '

                      'overwrite git hooks=%s' % (rm_obsolete, install_git_hooks, overwrite_git_hooks))

            filesystem_repos = ScmModel().repo_scan()

            added, removed = repo2db_mapper(filesystem_repos, rm_obsolete,

                                            install_git_hooks=install_git_hooks,

                                            user=request.authuser.username,

                                            overwrite_git_hooks=overwrite_git_hooks)

                h.link_to(safe_unicode(repo_name), h.url('summary_home', repo_name=repo_name)) for repo_name in added

            ) or '-'

            ) or '-'

            if invalidate_cache:

                log.debug('invalidating all repositories cache')

                i = 0

                for repo in Repository.query():

                    try:

                        ScmModel().mark_for_invalidation(repo.repo_name)

                        i += 1

                    except VCSError as e:

                        log.warning('VCS error invalidating %s: %s', repo.repo_name, e)

                h.flash(_('Invalidated %s repositories') % i, category='success')

            raise HTTPFound(location=url('admin_settings_mapping'))

        defaults = Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

            render('admin/settings/settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasPermissionAnyDecorator('hg.admin')

    def settings_global(self):

        c.active = 'global'

        if request.POST:

            application_form = ApplicationSettingsForm()()

            try:

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

            except formencode.Invalid as errors:

                return htmlfill.render(

                    render('admin/settings/settings.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8",

                    force_defaults=False)

            try:

                for setting in (

                    'title',

                    'realm',

                    'ga_code',

                    'captcha_public_key',

                    'captcha_private_key',

                ):

                    Setting.create_or_update(setting, form_result[setting])

                Session().commit()

                set_app_settings(config)

                h.flash(_('Updated application settings'), category='success')

            except Exception:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred while updating '

                          'application settings'),

                          category='error')

            raise HTTPFound(location=url('admin_settings_global'))

        defaults = Setting.get_app_settings()

        defaults.update(self._get_hg_ui_settings())

        return htmlfill.render(

            render('admin/settings/settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasPermissionAnyDecorator('hg.admin')

    def settings_visual(self):

        c.active = 'visual'

        if request.POST:

            application_form = ApplicationVisualisationForm()()

            try:

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

            except formencode.Invalid as errors:

                return htmlfill.render(

                    render('admin/settings/settings.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8",

                    force_defaults=False)

            try:

                settings = [

                    ('show_public_icon', 'show_public_icon', 'bool'),

                    ('show_private_icon', 'show_private_icon', 'bool'),

                    ('stylify_metalabels', 'stylify_metalabels', 'bool'),

                    ('repository_fields', 'repository_fields', 'bool'),

                    ('dashboard_items', 'dashboard_items', 'int'),

                    ('admin_grid_items', 'admin_grid_items', 'int'),

                    ('show_version', 'show_version', 'bool'),

                    ('use_gravatar', 'use_gravatar', 'bool'),

from kallithea.lib.auth import LoginRequired, \

    HasUserGroupPermissionLevelDecorator, HasPermissionAnyDecorator

from kallithea.lib.base import BaseController, render

from kallithea.model.scm import UserGroupList

from kallithea.model.user_group import UserGroupModel

from kallithea.model.repo import RepoModel

from kallithea.model.db import User, UserGroup, UserGroupToPerm, \

    UserGroupRepoToPerm, UserGroupRepoGroupToPerm

from kallithea.model.forms import UserGroupForm, UserGroupPermsForm, \

    CustomDefaultPermissionsForm

from kallithea.model.meta import Session

from kallithea.lib.utils import action_logger

log = logging.getLogger(__name__)

class UserGroupsController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    @LoginRequired(allow_default_user=True)

    def _before(self, *args, **kwargs):

        super(UserGroupsController, self)._before(*args, **kwargs)

        c.available_permissions = config['available_permissions']

    def __load_data(self, user_group_id):

        c.group_members_obj = sorted((x.user for x in c.user_group.members),

                                     key=lambda u: u.username.lower())

        c.group_members = [(x.user_id, x.username) for x in c.group_members_obj]

        c.available_members = sorted(((x.user_id, x.username) for x in

                                      User.query().all()),

                                     key=lambda u: u[1].lower())

    def __load_defaults(self, user_group_id):

        """

        Load defaults settings for edit, and update

        :param user_group_id:

        """

        user_group = UserGroup.get_or_404(user_group_id)

        data = user_group.get_dict()

        return data

    def index(self, format='html'):

        _list = UserGroup.query() \

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

                        .all()

        group_iter = UserGroupList(_list, perm_level='admin')

        user_groups_data = []

        total_records = len(group_iter)

        _tmpl_lookup = 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),

                "desc": h.escape(user_gr.user_group_description),

                "members": len(user_gr.members),

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

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

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

            })

        c.data = {

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

        users_group_form = UserGroupForm()()

        try:

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

            ug = UserGroupModel().create(name=form_result['users_group_name'],

                                         description=form_result['user_group_description'],

                                         owner=request.authuser.user_id,

                                         active=form_result['users_group_active'])

            gr = form_result['users_group_name']

            action_logger(request.authuser,

                          'admin_created_users_group:%s' % gr,

                          None, request.ip_addr)

                category='success')

            Session().commit()

        except formencode.Invalid as errors:

            return htmlfill.render(

                render('admin/user_groups/user_group_add.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during creation of user group %s')

                    % request.POST.get('users_group_name'), category='error')

        raise HTTPFound(location=url('users_groups'))

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

    def new(self, format='html'):

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

    @HasUserGroupPermissionLevelDecorator('admin')

    def update(self, id):

        c.user_group = UserGroup.get_or_404(id)

        c.active = 'settings'

        self.__load_data(id)

        available_members = [safe_unicode(x[0]) for x in c.available_members]

        users_group_form = UserGroupForm(edit=True,

                                         old_data=c.user_group.get_dict(),

                                         available_members=available_members)()

        try:

            form_result = users_group_form.to_python(request.POST)

            UserGroupModel().update(c.user_group, form_result)

            gr = form_result['users_group_name']

            action_logger(request.authuser,

                          'admin_updated_users_group:%s' % gr,

                          None, request.ip_addr)

            h.flash(_('Updated user group %s') % gr, category='success')

            Session().commit()

        except formencode.Invalid as errors:

            ug_model = UserGroupModel()

            defaults = errors.value

            e = errors.error_dict or {}

            defaults.update({

                'create_repo_perm': ug_model.has_perm(id,

                                                      'hg.create.repository'),

                'fork_repo_perm': ug_model.has_perm(id,

                                                    'hg.fork.repository'),

            })

            return htmlfill.render(

                render('admin/user_groups/user_group_edit.html'),

                defaults=defaults,

                errors=e,

                prefix_error=False,

                encoding="UTF-8",

                force_defaults=False)

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('Error occurred during update of user group %s')

                    % request.POST.get('users_group_name'), category='error')

        raise HTTPFound(location=url('edit_users_group', id=id))

    @HasUserGroupPermissionLevelDecorator('admin')

    def delete(self, id):

        usr_gr = UserGroup.get_or_404(id)

        try:

            UserGroupModel().delete(usr_gr)

            Session().commit()

            h.flash(_('Successfully deleted user group'), category='success')

        except UserGroupsAssignedException as e:

            h.flash(e, category='error')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of user group'),

                    category='error')

        raise HTTPFound(location=url('users_groups'))

    @HasUserGroupPermissionLevelDecorator('admin')

    def edit(self, id, format='html'):

        c.user_group = UserGroup.get_or_404(id)

        c.active = 'settings'

        self.__load_data(id)

        defaults = self.__load_defaults(id)

        return htmlfill.render(

            render('admin/user_groups/user_group_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

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

<%inherit file="/base/base.html"/>

<%block name="title">

    ${_('Edit Gist')} · ${c.gist.gist_access_id}

</%block>

<%block name="js_extra">

  <script type="text/javascript" src="${h.url('/codemirror/lib/codemirror.js')}"></script>

  <script type="text/javascript" src="${h.url('/js/codemirror_loadmode.js')}"></script>

  <script type="text/javascript" src="${h.url('/codemirror/mode/meta.js')}"></script>

</%block>

<%block name="css_extra">

  <link rel="stylesheet" type="text/css" href="${h.url('/codemirror/lib/codemirror.css')}"/>

</%block>

<%def name="breadcrumbs_links()">

    ${_('Edit Gist')} · ${c.gist.gist_access_id}

</%def>

<%block name="header_menu">

    ${self.menu('gists')}

</%block>

<%def name="main()">

<div class="panel panel-primary">

    <div class="panel-heading clearfix">

        ${self.breadcrumbs()}

    </div>

    <div class="panel-body">

        <div id="edit_error" style="display: none" class="flash_msg">

            <div class="alert alert-dismissable alert-warning">

              <button type="button" class="close" data-dismiss="alert" aria-hidden="true"><i class="icon-cancel-circled"></i></button>

                             % {'here': h.link_to(_('here'),h.url('edit_gist', gist_id=c.gist.gist_access_id))})}

            </div>

            <script>

            if (typeof jQuery != 'undefined') {

                $(".alert").alert();

            }

            </script>

        </div>

        <div id="files_data">

          ${h.form(h.url('edit_gist', gist_id=c.gist.gist_access_id), method='post', id='eform')}

            <div>

                <input type="hidden" value="${c.file_changeset.raw_id}" name="parent_hash">

                <textarea class="form-control"

                          id="description" name="description"

                          placeholder="${_('Gist description ...')}">${c.gist.gist_description}</textarea>

                <div>

                    <label>

                        ${_('Gist lifetime')}

                        ${h.select('lifetime', '0', c.lifetime_options)}

                    </label>

                    <span class="text-muted">

                     %if c.gist.gist_expires == -1:

                      ${_('Expires')}: ${_('Never')}

                     %else:

                      ${_('Expires')}: ${h.age(h.time_to_datetime(c.gist.gist_expires))}

                     %endif

                   </span>

                </div>

            </div>

            % for cnt, file in enumerate(c.files):

                <div id="body" class="panel panel-default form-inline">

                    <div class="panel-heading">

                        <input type="hidden" value="${h.safe_unicode(file.path)}" name="org_files">

                        <input class="form-control" id="filename_${h.FID('f',file.path)}" name="files" size="30" type="text" value="${h.safe_unicode(file.path)}">

                        <select class="form-control" id="mimetype_${h.FID('f',file.path)}" name="mimetypes"></select>

                    </div>

                    <div class="panel-body no-padding">

                        <div id="editor_container">

                            <textarea id="editor_${h.FID('f',file.path)}" name="contents" style="display:none">${file.content}</textarea>

                        </div>

                    </div>

                </div>

                ## dynamic edit box.

                <script type="text/javascript">

                    $(document).ready(function(){

                        var myCodeMirror = initCodeMirror(${h.js('editor_' + h.FID('f',file.path))}, ${h.jshtml(request.script_name)}, '');

                        //inject new modes

                        var $mimetype_select = $(${h.js('#mimetype_' + h.FID('f',file.path))});

                        $mimetype_select.each(function(){

                            var modes_select = this;

                            var index = 1;

                            for(var i=0;i<CodeMirror.modeInfo.length;i++) {

                                var m = CodeMirror.modeInfo[i];

                                var opt = new Option(m.name, m.mime);

                                $(opt).attr('mode', m.mode);

                                if (m.mime == 'text/plain') {

                                    // default plain text

                                    $(opt).prop('selected', true);

                                    modes_select.options[0] = opt;

                                } else {

                                    modes_select.options[index++] = opt;

                                }

                            }

                        });

                        var $filename_input = $(${h.js('#filename_' + h.FID('f',file.path))});

                        // on select change set new mode

                        $mimetype_select.change(function(e){

                            var selected = e.currentTarget;

                            var node = selected.options[selected.selectedIndex];

                            var detected_mode = CodeMirror.findModeByMIME(node.value);

                            setCodeMirrorMode(myCodeMirror, detected_mode);

                            var proposed_ext = CodeMirror.findExtensionByMode(detected_mode);

                            var file_data = CodeMirror.getFilenameAndExt($filename_input.val());

                            var filename = file_data['filename'] || 'filename1';

                            $filename_input.val(filename + '.' + proposed_ext);

                        });

                        // on type the new filename set mode

                        $filename_input.keyup(function(e){

                            var file_data = CodeMirror.getFilenameAndExt(this.value);

                            if(file_data['ext'] != null){

                                var detected_mode = CodeMirror.findModeByExtension(file_data['ext']) || CodeMirror.findModeByMIME('text/plain');

                                if (detected_mode){

                                    setCodeMirrorMode(myCodeMirror, detected_mode);

                                    $mimetype_select.val(detected_mode.mime);

                                }

                            }

                        });

${h.form(url('admin_permissions'), method='post')}

    <div class="form">

            <div class="form-group">

                <label class="control-label" for="anonymous">${_('Anonymous access')}:</label>

                <div class="form-inline">

                    <label>

                        ${h.checkbox('anonymous',True)}

                        <span>${_('Allow anonymous access')}</span>

                    </label>

                </div>

            </div>

            <div class="form-group">

                <label class="control-label" for="default_repo_perm">${_('Repository')}:</label>

                <div class="form-inline">

                    ${h.select('default_repo_perm','',c.repo_perms_choices,class_='form-control')}

                    <label>

                        ${h.checkbox('overwrite_default_repo','true')}

                        <span data-toggle="tooltip" title="${_('All default permissions on each repository will be reset to chosen permission, note that all custom default permission on repositories will be lost')}">

                            ${_('Apply to all existing repositories')}

                        </span>

                    </label>

                    <span class="help-block">${_('Permissions for the Default user on new repositories.')}</span>

                </div>

            </div>

            <div class="form-group">

                <label class="control-label" for="default_group_perm">${_('Repository group')}:</label>

                <div class="form-inline">

                    ${h.select('default_group_perm','',c.group_perms_choices,class_='form-control')}

                    <label>

                        ${h.checkbox('overwrite_default_group','true')}

                        <span data-toggle="tooltip" title="${_('All default permissions on each repository group will be reset to chosen permission, note that all custom default permission on repository groups will be lost')}">

                            ${_('Apply to all existing repository groups')}

                        </span>

                    </label>

                    <span class="help-block">${_('Permissions for the Default user on new repository groups.')}</span>

                </div>

            </div>

            <div class="form-group">

                <label class="control-label" for="default_user_group_perm">${_('User group')}:</label>

                <div class="form-inline">

                    ${h.select('default_user_group_perm','',c.user_group_perms_choices,class_='form-control')}

                    <label>

                        ${h.checkbox('overwrite_default_user_group','true')}

                        <span data-toggle="tooltip" title="${_('All default permissions on each user group will be reset to chosen permission, note that all custom default permission on user groups will be lost')}">

                            ${_('Apply to all existing user groups')}

                        </span>

                    </label>

                    <span class="help-block">${_('Permissions for the Default user on new user groups.')}</span>

                </div>

            </div>

            <div class="form-group">

                <label class="control-label" for="default_repo_create">${_('Top level repository creation')}:</label>

                <div>

                    ${h.select('default_repo_create','',c.repo_create_choices,class_='form-control')}

                    <span class="help-block">${_('Enable this to allow non-admins to create repositories at the top level.')}</span>

                    <span class="help-block">${_('Note: This will also give all users API access to create repositories everywhere. That might change in future versions.')}</span>

                </div>

            </div>

            <div class="form-group">

                <label class="control-label" for="create_on_write">${_('Repository creation with group write access')}:</label>

                <div>

                    ${h.select('create_on_write','',c.repo_create_on_write_choices,class_='form-control')}

                    <span class="help-block">${_('With this, write permission to a repository group allows creating repositories inside that group. Without this, group write permissions mean nothing.')}</span>

                </div>

            </div>

            <div class="form-group">

                <label class="control-label" for="default_user_group_create">${_('User group creation')}:</label>

                <div>

                    ${h.select('default_user_group_create','',c.user_group_create_choices,class_='form-control')}

                    <span class="help-block">${_('Enable this to allow non-admins to create user groups.')}</span>

                </div>

            </div>

            <div class="form-group">

                <label class="control-label" for="default_fork">${_('Repository forking')}:</label>

                <div>

                    ${h.select('default_fork','',c.fork_choices,class_='form-control')}

                    <span class="help-block">${_('Enable this to allow non-admins to fork repositories.')}</span>

                </div>

            </div>

            <div class="form-group">

                <label class="control-label" for="default_register">${_('Registration')}:</label>

                <div>

                    ${h.select('default_register','',c.register_choices,class_='form-control')}

                </div>

            </div>

            <div class="form-group">

                <label class="control-label" for="default_extern_activate">${_('External auth account activation')}:</label>

                <div>

                    ${h.select('default_extern_activate','',c.extern_activate_choices,class_='form-control')}

                </div>

            </div>

            <div class="form-group">

                <div class="buttons">

                    ${h.submit('save',_('Save'),class_="btn btn-default")}

                    ${h.reset('reset',_('Reset'),class_="btn btn-default")}

                </div>

            </div>

    </div>

${h.end_form()}

<table class="table">

    %if c.default_user_ip_map and c.inherit_default_ips:

        %for ip in c.default_user_ip_map:

          <tr>

            <td><div class="ip">${ip.ip_addr}</div></td>

            <td><div class="ip">${h.ip_range(ip.ip_addr)}</div></td>

          </tr>

        %endfor

    %endif

    %if c.user_ip_map:

        %for ip in c.user_ip_map:

          <tr>

            <td><div class="ip">${ip.ip_addr}</div></td>