"""

        Load defaults settings for edit, and update

        :param repo_name:

        """

        c.repo_info = self._load_repo(repo_name)

        self.__load_defaults(c.repo_info)

        ##override defaults for exact repo info here git/hg etc

        choices, c.landing_revs = ScmModel().get_repo_landing_revs(c.repo_info)

        c.landing_revs_choices = choices

        defaults = RepoModel()._get_defaults(repo_name)

        return defaults

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

        """GET /repos: All items in the collection"""

        # url('repos')

        _list = Repository.query()\

                        .order_by(func.lower(Repository.repo_name))\

                        .all()

        c.repos_list = RepoList(_list, perm_set=['repository.admin'])

        repos_data = RepoModel().get_repos_as_dict(repos_list=c.repos_list,

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

            from kallithea import CELERY_ON

            from celery.result import AsyncResult

            if CELERY_ON:

                task = 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')

            else:

                repo_url = h.link_to(repo.repo_name,

                                     h.url('summary_home',

                                           repo_name=repo.repo_name))

                fork = repo.fork

                if fork:

                    fork_name = fork.repo_name

                    h.flash(h.literal(_('Forked repository %s as %s')

                            % (fork_name, repo_url)), category='success')

                else:

                    h.flash(h.literal(_('Created repository %s') % repo_url),

                            category='success')

        return redirect(url('repos'))

    @HasPermissionAllDecorator('hg.admin')

    def show(self, repo_name, format='html'):

        """GET /repos/repo_name: Show a specific item"""

        # url('repo', repo_name=ID)

    @HasRepoPermissionAllDecorator('repository.admin')

    def edit(self, repo_name):

        """GET /repo_name/settings: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        defaults = self.__load_data(repo_name)

        c.repo_fields = RepositoryField.query()\

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

        repo_model = RepoModel()

        c.users_array = repo_model.get_users_js()

        c.active = 'settings'

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasRepoPermissionAllDecorator('repository.admin')

import hashlib

import StringIO

import math

import logging

import re

import urlparse

import textwrap

from pygments.formatters.html import HtmlFormatter

from pygments import highlight as code_highlight

from pylons import url

from pylons.i18n.translation import _, ungettext

from webhelpers.html import literal, HTML, escape

from webhelpers.html.tools import *

from webhelpers.html.builder import make_tag

from webhelpers.html.tags import auto_discovery_link, checkbox, css_classes, \

    end_form, file, hidden, image, javascript_link, link_to, \

    link_to_if, link_to_unless, ol, required_legend, select, stylesheet_link, \

    submit, text, password, textarea, title, ul, xml_declaration, radio

from webhelpers.html.tools import auto_link, button_to, highlight, \

    js_obfuscate, mail_to, strip_links, strip_tags, tag_re

from webhelpers.number import format_byte_size, format_bit_size

from webhelpers.pylonslib import Flash as _Flash

        repo_private = v.StringBoolean(if_missing=False)

        repo_landing_rev = v.OneOf(landing_revs, hideList=True)

        repo_copy_permissions = v.StringBoolean(if_missing=False)

        clone_uri = All(v.UnicodeString(strip=True, min=1, not_empty=False))

        repo_enable_statistics = v.StringBoolean(if_missing=False)

        repo_enable_downloads = v.StringBoolean(if_missing=False)

        repo_enable_locking = v.StringBoolean(if_missing=False)

        if edit:

            #this is repo owner

            user = All(v.UnicodeString(not_empty=True), v.ValidRepoUser())

        chained_validators = [v.ValidCloneUri(),

                              v.ValidRepoName(edit, old_data)]

    return _RepoForm

def RepoPermsForm():

    class _RepoPermsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        chained_validators = [v.ValidPerms(type_='repo')]

    return _RepoPermsForm

        return defaults

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

        try:

            cur_repo = self._get_repo(repo)

            org_repo_name = cur_repo.repo_name

            if 'user' in kwargs:

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

            if 'repo_group' in kwargs:

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

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

                if k in kwargs:

            new_name = cur_repo.get_new_name(kwargs['repo_name'])

            cur_repo.repo_name = new_name

            #if private flag is set, reset default permission to NONE

            if kwargs.get('repo_private'):

                EMPTY_PERM = 'repository.none'

                RepoModel().grant_user_permission(

                    repo=cur_repo, user='default', perm=EMPTY_PERM

                )

                #handle extra fields

            for field in filter(lambda k: k.startswith(RepositoryField.PREFIX),

from kallithea.model.db import RepoGroup, Repository, UserGroup, User,\

    ChangesetStatus

from kallithea.lib.exceptions import LdapImportError

from kallithea.config.routing import ADMIN_PREFIX

from kallithea.lib.auth import HasRepoGroupPermissionAny, HasPermissionAny

# silence warnings and pylint

UnicodeString, OneOf, Int, Number, Regex, Email, Bool, StringBoolean, Set, \

    NotEmpty, IPAddress, CIDR, String, FancyValidator

log = logging.getLogger(__name__)

class StateObj(object):

    """

    this is needed to translate the messages using _() in validators

    """

    _ = staticmethod(_)

def M(self, key, state=None, **kwargs):

    """

    returns string from self.message based on given key,

    passed kw params are used to substitute %(named)s params inside

    class _validator(formencode.validators.FancyValidator):

        messages = {

            'clone_uri': _(u'Invalid repository URL'),

            'invalid_clone_uri': _(u'Invalid repository URL. It must be a '

                                    'valid http, https, ssh, svn+http or svn+https URL'),

        }

        def validate_python(self, value, state):

            repo_type = value.get('repo_type')

            url = value.get('clone_uri')

                try:

                    url_handler(repo_type, url, make_ui('db', clear_session=False))

                except Exception:

                    log.exception('URL validation failed')

                    msg = M(self, 'clone_uri')

                    raise formencode.Invalid(msg, value, state,

                        error_dict=dict(clone_uri=msg)

                    )

    return _validator

def ValidForkType(old_data={}):

                    <span id="clone_id" class="help-block" style="display: none">

                        ${_('URL by id')}: `${c.repo_info.clone_url(with_id=True)}` </br>

                        ${_('''In case this repository is renamed or moved into another group the repository URL changes.

                               Using the above permanent URL guarantees that this repository always will be accessible on that URL.

                               This is useful for CI systems, or any other cases that you need to hardcode the URL into a 3rd party service.''')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label">

                    <label for="clone_uri">${_('Remote repository')}:</label>

                </div>

                <div class="input">

                  <span id="alter_clone_uri_help_block" class="help-block">

                    ${_('Optional: URL of a remote repository. If set, the repository can be pulled from this URL.')}

                  </span>

                </div>

            </div>

            <div class="field">

                <div class="label">

                    <label for="repo_group">${_('Repository group')}:</label>

                </div>

                <div class="input">

                    ${h.select('repo_group','',c.repo_groups,class_="medium")}

                    <span class="help-block">${_('Optionally select a group to put this repository into.')}</span>

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

            </div>

        </div>

    </div>

    ${h.end_form()}

<script>

    $(document).ready(function(){

        $('#show_more_clone_id').on('click', function(e){

            $('#clone_id').show();

            e.preventDefault();

        });

        $('#repo_landing_rev').select2({

            'dropdownAutoWidth': true

        });

        $('#repo_group').select2({

            'dropdownAutoWidth': true

        });

        // autocomplete

        var _USERS_AC_DATA = ${c.users_array|n};

        SimpleUserAutoComplete('user', 'owner_container', _USERS_AC_DATA);

    });