defaults = RepoModel()._get_defaults(repo_name)

        c.repos_list = [('', _('--REMOVE FORK--'))]

        c.repos_list += [(x.repo_id, x.repo_name) for x in

                    Repository.query().order_by(Repository.repo_name).all()

                    if x.repo_id != c.repo_info.repo_id]

        defaults['id_fork_of'] = db_repo.fork.repo_id if db_repo.fork else ''

        return defaults

    @HasPermissionAllDecorator('hg.admin')

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

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

        # url('repos')

        c.repos_list = Repository.query()\

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

                        .all()

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

                                                   admin=True,

                                                   super_user_actions=True)

        #json used to render the grid

        c.data = json.dumps(repos_data)

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

    @NotAnonymous()

    def create(self):

        """

        POST /repos: Create a new item"""

        # url('repos')

        self.__load_defaults()

        form_result = {}

        try:

            form_result = RepoForm(repo_groups=c.repo_groups_choices,

                                   landing_revs=c.landing_revs_choices)()\

                            .to_python(dict(request.POST))

            new_repo = RepoModel().create(form_result,

                                          self.rhodecode_user.user_id)

            if form_result['clone_uri']:

                h.flash(_('created repository %s from %s') \

                    % (form_result['repo_name'], form_result['clone_uri']),

                    category='success')

            else:

            if request.POST.get('user_created'):

                # created by regular non admin user

                action_logger(self.rhodecode_user, 'user_created_repo',

                              form_result['repo_name_full'], self.ip_addr,

                              self.sa)

            else:

                action_logger(self.rhodecode_user, 'admin_created_repo',

                              form_result['repo_name_full'], self.ip_addr,

                              self.sa)

            Session().commit()

        except formencode.Invalid, errors:

            return htmlfill.render(

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

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            msg = _('error occurred during creation of repository %s') \

                    % form_result.get('repo_name')

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

            if c.rhodecode_user.is_admin:

                return redirect(url('repos'))

            return redirect(url('home'))

        #redirect to our new repo !

        return redirect(url('summary_home', repo_name=new_repo.repo_name))

    @HasPermissionAllDecorator('hg.admin')

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

        """

        WARNING: this function is depracated see settings.create_repo !!

        GET /repos/new: Form to create a new item

        """

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

        self.__load_defaults()

        ## apply the defaults from defaults page

        defaults = RhodeCodeSetting.get_default_repo_settings(strip_prefix=True)

        if parent_group:

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

        return htmlfill.render(

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

            defaults=defaults,

from rhodecode.lib.compat import OrderedDict

from rhodecode.lib.utils2 import convert_line_endings, detect_mode, safe_str,\

    str2bool

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.vcs.backends.base import EmptyChangeset

from rhodecode.lib.vcs.conf import settings

from rhodecode.lib.vcs.exceptions import RepositoryError, \

    ChangesetDoesNotExistError, EmptyRepositoryError, \

    ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError,\

    NodeDoesNotExistError, ChangesetError, NodeError

from rhodecode.lib.vcs.nodes import FileNode

from rhodecode.model.repo import RepoModel

from rhodecode.model.scm import ScmModel

from rhodecode.model.db import Repository

from rhodecode.controllers.changeset import anchor_url, _ignorews_url,\

    _context_url, get_line_ctx, get_ignore_ws

log = logging.getLogger(__name__)

class FilesController(BaseRepoController):

    def __before__(self):

        super(FilesController, self).__before__()

        c.cut_off_limit = self.cut_off_limit

    def __get_cs_or_redirect(self, rev, repo_name, redirect_after=True):

        """

        Safe way to get changeset if error occur it redirects to tip with

        proper message

        :param rev: revision to fetch

        :param repo_name: repo name to redirect after

        """

        try:

            return c.rhodecode_repo.get_changeset(rev)

        except EmptyRepositoryError, e:

            if not redirect_after:

                return None

            url_ = url('files_add_home',

                       repo_name=c.repo_name,

                       revision=0, f_path='')

            h.flash(h.literal(_('There are no files yet %s') % add_new),

                    category='warning')

            redirect(h.url('summary_home', repo_name=repo_name))

        except RepositoryError, e:

            h.flash(str(e), category='warning')

            redirect(h.url('files_home', repo_name=repo_name, revision='tip'))

    def __get_filenode_or_redirect(self, repo_name, cs, path):

        """

        Returns file_node, if error occurs or given path is directory,

        it'll redirect to top level path

        :param repo_name: repo_name

        :param cs: given changeset

        :param path: path to lookup

        """

        try:

            file_node = cs.get_node(path)

            if file_node.is_dir():

                raise RepositoryError('given path is a directory')

        except RepositoryError, e:

            h.flash(str(e), category='warning')

            redirect(h.url('files_home', repo_name=repo_name,

                           revision=cs.raw_id))

        return file_node

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def index(self, repo_name, revision, f_path, annotate=False):

        # redirect to given revision from form if given

        post_revision = request.POST.get('at_rev', None)

        if post_revision:

            cs = self.__get_cs_or_redirect(post_revision, repo_name)

            redirect(url('files_home', repo_name=c.repo_name,

                         revision=cs.raw_id, f_path=f_path))

        c.changeset = self.__get_cs_or_redirect(revision, repo_name)

        c.branch = request.GET.get('branch', None)

        c.f_path = f_path

        c.annotate = annotate

        c.changeset = self.__get_cs_or_redirect(revision, repo_name)

        cur_rev = c.changeset.revision

        # prev link

            )(r.repo_name, 'get forks check'):

                continue

            d.append(r)

        c.forks_pager = Page(d, page=p, items_per_page=20)

        c.forks_data = render('/forks/forks_data.html')

        if request.environ.get('HTTP_X_PARTIAL_XHR'):

            return c.forks_data

        return render('/forks/forks.html')

    @NotAnonymous()

    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def fork(self, repo_name):

        c.repo_info = Repository.get_by_repo_name(repo_name)

        if not c.repo_info:

            h.not_mapped_error(repo_name)

            return redirect(url('home'))

        defaults = self.__load_data(repo_name)

        return htmlfill.render(

            render('forks/fork.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    @NotAnonymous()

    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def fork_create(self, repo_name):

        self.__load_defaults()

        c.repo_info = Repository.get_by_repo_name(repo_name)

        _form = RepoForkForm(old_data={'repo_type': c.repo_info.repo_type},

                             repo_groups=c.repo_groups_choices,

                             landing_revs=c.landing_revs_choices)()

        form_result = {}

        try:

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

            # create fork is done sometimes async on celery, db transaction

            # management is handled there.

            RepoModel().create_fork(form_result, self.rhodecode_user.user_id)

                    category='success')

        except formencode.Invalid, errors:

            c.new_repo = errors.value['repo_name']

            return htmlfill.render(

                render('forks/fork.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during repository forking %s') %

                    repo_name, category='error')

        return redirect(url('home'))

    min-width: 150px;

    max-height: 250px;

    z-index: 1;

}

.breadcrumbs {

    border: medium none;

    color: #FFF;

    float: left;

    font-weight: 700;

    font-size: 14px;

    margin: 0;

    padding: 11px 0 11px 10px;

}

.breadcrumbs .hash {

    text-transform: none;

    color: #fff;

}

.breadcrumbs a {

    color: #FFF;

}

.flash_msg {

}

.flash_msg ul {

}

.error_red {

    color: red;

}

.error_msg {

    background-color: #c43c35;

    background-repeat: repeat-x;

    background-image: -khtml-gradient(linear, left top, left bottom, from(#ee5f5b), to(#c43c35) );

    background-image: -moz-linear-gradient(top, #ee5f5b, #c43c35);

    background-image: -ms-linear-gradient(top, #ee5f5b, #c43c35);

    background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #ee5f5b), color-stop(100%, #c43c35) );

    background-image: -webkit-linear-gradient(top, #ee5f5b, #c43c35);

    background-image: -o-linear-gradient(top, #ee5f5b, #c43c35);

    background-image: linear-gradient(to bottom, #ee5f5b, #c43c35);

    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#ee5f5b',endColorstr='#c43c35', GradientType=0 );

    border-color: #c43c35 #c43c35 #882a25;

}

.warning_msg {

    color: #404040 !important;

    background-color: #eedc94;

    background-repeat: repeat-x;

    background-image: -khtml-gradient(linear, left top, left bottom, from(#fceec1), to(#eedc94) );

    background-image: -moz-linear-gradient(top, #fceec1, #eedc94);

    background-image: -ms-linear-gradient(top, #fceec1, #eedc94);

    background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #fceec1), color-stop(100%, #eedc94) );

    background-image: -webkit-linear-gradient(top, #fceec1, #eedc94);

    background-image: -o-linear-gradient(top, #fceec1, #eedc94);

    background-image: linear-gradient(to bottom, #fceec1, #eedc94);

    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#fceec1', endColorstr='#eedc94', GradientType=0 );

    border-color: #eedc94 #eedc94 #e4c652;

}

.success_msg {

    background-color: #57a957;

    background-repeat: repeat-x !important;

    background-image: -khtml-gradient(linear, left top, left bottom, from(#62c462), to(#57a957) );

    background-image: -moz-linear-gradient(top, #62c462, #57a957);

    background-image: -ms-linear-gradient(top, #62c462, #57a957);

    background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #62c462), color-stop(100%, #57a957) );

    background-image: -webkit-linear-gradient(top, #62c462, #57a957);

    background-image: -o-linear-gradient(top, #62c462, #57a957);

    background-image: linear-gradient(to bottom, #62c462, #57a957);

    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#62c462', endColorstr='#57a957', GradientType=0 );

    border-color: #57a957 #57a957 #3d773d;

}

.notice_msg {

    background-color: #339bb9;

    background-repeat: repeat-x;

    background-image: -khtml-gradient(linear, left top, left bottom, from(#5bc0de), to(#339bb9) );

    background-image: -moz-linear-gradient(top, #5bc0de, #339bb9);

    background-image: -ms-linear-gradient(top, #5bc0de, #339bb9);

    background-image: -webkit-gradient(linear, left top, left bottom, color-stop(0%, #5bc0de), color-stop(100%, #339bb9) );

    background-image: -webkit-linear-gradient(top, #5bc0de, #339bb9);

    background-image: -o-linear-gradient(top, #5bc0de, #339bb9);

    background-image: linear-gradient(to bottom, #5bc0de, #339bb9);

    filter: progid:DXImageTransform.Microsoft.gradient(startColorstr='#5bc0de', endColorstr='#339bb9', GradientType=0 );

    border-color: #339bb9 #339bb9 #22697d;

}

.success_msg, .error_msg, .notice_msg, .warning_msg {

    font-size: 12px;

    font-weight: 700;

    min-height: 14px;

    line-height: 14px;

    margin-bottom: 10px;

    margin-top: 0;

    display: block;

    overflow: auto;

    padding: 6px 10px 6px 10px;

    border-color: rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);

    position: relative;

    color: #FFF;

    border-width: 1px;

    border-style: solid;

    -webkit-border-radius: 4px;

    border-radius: 4px;

    -webkit-box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.25);

    box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.25);

}

#msg_close {

    background: transparent url("../icons/cross_grey_small.png") no-repeat scroll 0 0;

    cursor: pointer;

    height: 16px;

    position: absolute;

    right: 5px;

    top: 5px;

    width: 16px;

}

div#legend_data {

    padding-left: 10px;

}

div#legend_container table {

    border: none !important;

}

div#legend_container table, div#legend_choices table {

    width: auto !important;

}

table#permissions_manage {

    width: 0 !important;

}

table#permissions_manage span.private_repo_msg {

    font-size: 0.8em;

    opacity: 0.6;

}