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

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

    @HasRepoPermissionLevelDecorator('admin')

    def create_repo_field(self, repo_name):

        try:

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

            new_field = RepositoryField()

            new_field.repository = Repository.get_by_repo_name(repo_name)

            new_field.field_key = form_result['new_field_key']

            new_field.field_type = form_result['new_field_type']  # python type

            new_field.field_value = form_result['new_field_value']  # set initial blank value

            new_field.field_desc = form_result['new_field_desc']

            new_field.field_label = form_result['new_field_label']

            Session().add(new_field)

            Session().commit()

        except formencode.Invalid as e:

            h.flash(_('Field validation error: %s') % e.msg, category='error')

        except Exception as e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during creation of field: %r') % e, category='error')

        raise HTTPFound(location=url('edit_repo_fields', repo_name=repo_name))

    @HasRepoPermissionLevelDecorator('admin')

    def delete_repo_field(self, repo_name, field_id):

        field = RepositoryField.get_or_404(field_id)

        try:

            Session().delete(field)

            Session().commit()

        except Exception as e:

            log.error(traceback.format_exc())

            msg = _('An error occurred during removal of field')

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

        raise HTTPFound(location=url('edit_repo_fields', repo_name=repo_name))

    @HasRepoPermissionLevelDecorator('admin')

    def edit_advanced(self, repo_name):

        c.repo_info = self._load_repo()

        c.default_user_id = User.get_default_user().user_id

        c.in_public_journal = UserFollowing.query() \

            .filter(UserFollowing.user_id == c.default_user_id) \

            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        _repos = Repository.query(sorted=True).all()

        read_access_repos = RepoList(_repos, perm_level='read')

        c.repos_list = [(None, _('-- Not a fork --'))]

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

                         for x in read_access_repos

        defaults = {

            'id_fork_of': c.repo_info.fork_id if c.repo_info.fork_id else ''

        }

        c.active = 'advanced'

        if request.POST:

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

        return htmlfill.render(

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

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    @HasRepoPermissionLevelDecorator('admin')

    def edit_advanced_journal(self, repo_name):

        """

        Sets this repository to be visible in public journal,

        in other words asking default user to follow this repo

        :param repo_name:

        """

        try:

            repo_id = Repository.get_by_repo_name(repo_name).repo_id

            user_id = User.get_default_user().user_id

            self.scm_model.toggle_following_repo(repo_id, user_id)

            h.flash(_('Updated repository visibility in public journal'),

                    category='success')

            Session().commit()

        except Exception:

            h.flash(_('An error occurred during setting this'

                      ' repository in public journal'),

                    category='error')

        raise HTTPFound(location=url('edit_repo_advanced', repo_name=repo_name))

    @HasRepoPermissionLevelDecorator('admin')

    def edit_advanced_fork(self, repo_name):

        """

        Mark given repository as a fork of another

        :param repo_name:

        """

        try:

            fork_id = request.POST.get('id_fork_of')

            repo = ScmModel().mark_as_fork(repo_name, fork_id,

                                           request.authuser.username)

            fork = repo.fork.repo_name if repo.fork else _('Nothing')

    repo_field_id = Column(Integer(), primary_key=True)

    repository_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    field_key = Column(String(250), nullable=False)

    field_label = Column(String(1024), nullable=False)

    field_value = Column(String(10000), nullable=False)

    field_desc = Column(String(1024), nullable=False)

    field_type = Column(String(255), nullable=False)

    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    repository = relationship('Repository')

    @property

    def field_key_prefixed(self):

        return 'ex_%s' % self.field_key

    @classmethod

    def un_prefix_key(cls, key):

        if key.startswith(cls.PREFIX):

            return key[len(cls.PREFIX):]

        return key

    @classmethod

    def get_by_key_name(cls, key, repo):

        row = cls.query() \

                .filter(cls.repository == repo) \

                .filter(cls.field_key == key).scalar()

        return row

class Repository(Base, BaseDbModel):

    __tablename__ = 'repositories'

    __table_args__ = (

        Index('r_repo_name_idx', 'repo_name'),

        _table_args_default_dict,

    )

    DEFAULT_CLONE_URI = '{scheme}://{user}@{netloc}/{repo}'

    DEFAULT_CLONE_SSH = 'ssh://{system_user}@{hostname}/{repo}'

    STATE_CREATED = u'repo_state_created'

    STATE_PENDING = u'repo_state_pending'

    STATE_ERROR = u'repo_state_error'

    repo_id = Column(Integer(), primary_key=True)

    repo_name = Column(Unicode(255), nullable=False, unique=True)

    repo_state = Column(String(255), nullable=False)

    clone_uri = Column(String(255), nullable=True) # FIXME: not nullable?

    owner_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

    private = Column(Boolean(), nullable=False)

    enable_statistics = Column("statistics", Boolean(), nullable=False, default=True)

    enable_downloads = Column("downloads", Boolean(), nullable=False, default=True)

    description = Column(Unicode(10000), nullable=False)

    created_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    updated_on = Column(DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    _landing_revision = Column("landing_revision", String(255), nullable=False)

    _changeset_cache = Column("changeset_cache", LargeBinary(), nullable=True) # JSON data # FIXME: not nullable?

    fork_id = Column(Integer(), ForeignKey('repositories.repo_id'), nullable=True)

    group_id = Column(Integer(), ForeignKey('groups.group_id'), nullable=True)

    owner = relationship('User')

    fork = relationship('Repository', remote_side=repo_id)

    group = relationship('RepoGroup')

    repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id')

    users_group_to_perm = relationship('UserGroupRepoToPerm', cascade='all')

    stats = relationship('Statistics', cascade='all', uselist=False)

    followers = relationship('UserFollowing',

                             primaryjoin='UserFollowing.follows_repository_id==Repository.repo_id',

                             cascade='all')

    extra_fields = relationship('RepositoryField',

                                cascade="all, delete-orphan")

    logs = relationship('UserLog')

    comments = relationship('ChangesetComment', cascade="all, delete-orphan")

    pull_requests_org = relationship('PullRequest',

                    primaryjoin='PullRequest.org_repo_id==Repository.repo_id',

                    cascade="all, delete-orphan")

    pull_requests_other = relationship('PullRequest',

                    primaryjoin='PullRequest.other_repo_id==Repository.repo_id',

                    cascade="all, delete-orphan")

    def __unicode__(self):

        return u"<%s('%s:%s')>" % (self.__class__.__name__, self.repo_id,

                                   safe_unicode(self.repo_name))

    @hybrid_property

    def landing_rev(self):

        # always should return [rev_type, rev]

        if self._landing_revision:

            _rev_info = self._landing_revision.split(':')

            if len(_rev_info) < 2:

                _rev_info.insert(0, 'rev')