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

            c.f_path = f_path

            c.changeset = c.repo.get_changeset(revision)

            cur_rev = c.changeset.revision

            #prev link

            try:

                prev_rev = c.repo.get_changeset(cur_rev).prev(c.branch).raw_id

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

                             revision=prev_rev, f_path=f_path)

                if c.branch:

                    c.url_prev += '?branch=%s' % c.branch

            except ChangesetDoesNotExistError:

                c.url_prev = '#'

            #next link

            try:

                next_rev = c.repo.get_changeset(cur_rev).next(c.branch).raw_id

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

                         revision=next_rev, f_path=f_path)

                if c.branch:

                    c.url_next += '?branch=%s' % c.branch

            except ChangesetDoesNotExistError:

                c.url_next = '#'

            #files

            try:

                c.files_list = c.changeset.get_node(f_path)

                c.file_history = self._get_history(c.repo, c.files_list, f_path)

            except RepositoryError, e:

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

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

        except EmptyRepositoryError, e:

            h.flash(_('There are no files yet'), 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'))

        return render('files/files.html')

    def rawfile(self, repo_name, revision, f_path):

        hg_model = ScmModel()

        c.repo = hg_model.get_repo(c.repo_name)

        file_node = c.repo.get_changeset(revision).get_node(f_path)

        response.content_type = file_node.mimetype

        response.content_disposition = 'attachment; filename=%s' \

                                                    % f_path.split('/')[-1]

        return file_node.content

    def raw(self, repo_name, revision, f_path):

        hg_model = ScmModel()

        c.repo = hg_model.get_repo(c.repo_name)

        file_node = c.repo.get_changeset(revision).get_node(f_path)

        response.content_type = 'text/plain'

        return file_node.content

    def annotate(self, repo_name, revision, f_path):

        hg_model = ScmModel()

        c.repo = hg_model.get_repo(c.repo_name)

        try:

            c.cs = c.repo.get_changeset(revision)

            c.file = c.cs.get_node(f_path)

        except RepositoryError, e:

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

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

        c.file_history = self._get_history(c.repo, c.file, f_path)

        c.f_path = f_path

        return render('files/files_annotate.html')

    def archivefile(self, repo_name, fname):

        fileformat = None

        revision = None

        ext = None

        for a_type, ext_data in ARCHIVE_SPECS.items():

            archive_spec = fname.split(ext_data[1])

            if len(archive_spec) == 2 and archive_spec[1] == '':

                fileformat = a_type or ext_data[1]

                revision = archive_spec[0]

                ext = ext_data[1]

        try:

            repo = ScmModel().get_repo(repo_name)

            cs = repo.get_changeset(revision)

            content_type = ARCHIVE_SPECS[fileformat][0]

        except ChangesetDoesNotExistError:

            return _('Unknown revision %s') % revision

        except EmptyRepositoryError:

            return _('Empty repository')

        except (ImproperArchiveTypeError, KeyError):

            return _('Unknown archive type')

        response.content_type = content_type

        response.content_disposition = 'attachment; filename=%s-%s%s' \

            % (repo_name, revision, ext)

        return cs.get_chunked_archive(kind=fileformat)

    def diff(self, repo_name, f_path):

        hg_model = ScmModel()

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

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

        c.action = request.GET.get('diff')

        c.no_changes = diff1 == diff2

        c.f_path = f_path

        c.repo = hg_model.get_repo(c.repo_name)

        try:

            if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_1 = c.repo.get_changeset(diff1)

                node1 = c.changeset_1.get_node(f_path)

            else:

                c.changeset_1 = EmptyChangeset()

                node1 = FileNode('.', '', changeset=c.changeset_1)

            if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_2 = c.repo.get_changeset(diff2)

                node2 = c.changeset_2.get_node(f_path)

            else:

                c.changeset_2 = EmptyChangeset()

                node2 = FileNode('.', '', changeset=c.changeset_2)

        except RepositoryError:

            return redirect(url('files_home',

                                repo_name=c.repo_name, f_path=f_path))

        f_udiff = differ.get_udiff(node1, node2)

        diff = differ.DiffProcessor(f_udiff)

        if c.action == 'download':

            diff_name = '%s_vs_%s.diff' % (diff1, diff2)

            response.content_type = 'text/plain'

            response.content_disposition = 'attachment; filename=%s' \

                                                    % diff_name

            return diff.raw_diff()

        elif c.action == 'raw':

            response.content_type = 'text/plain'

            return diff.raw_diff()

        elif c.action == 'diff':

            if node1.size > self.cut_off_limit or node2.size > self.cut_off_limit:

                c.cur_diff = _('Diff is to big to display')

            else:

                c.cur_diff = diff.as_html()

        else:

            #default option

            if node1.size > self.cut_off_limit or node2.size > self.cut_off_limit:

                c.cur_diff = _('Diff is to big to display')

            else:

                c.cur_diff = diff.as_html()

        if not c.cur_diff: c.no_changes = True

        return render('files/file_diff.html')

    def _get_history(self, repo, node, f_path):

        from vcs.nodes import NodeKind

        if not node.kind is NodeKind.FILE:

            return []

        changesets = node.history

        hist_l = []

        changesets_group = ([], _("Changesets"))

        branches_group = ([], _("Branches"))

        tags_group = ([], _("Tags"))

        for chs in changesets:

            n_desc = 'r%s:%s' % (chs.revision, chs.short_id)

            changesets_group[0].append((chs.raw_id, n_desc,))

        hist_l.append(changesets_group)

        for name, chs in c.repository_branches.items():

            #chs = chs.split(':')[-1]

            branches_group[0].append((chs, name),)

        hist_l.append(branches_group)

        for name, chs in c.repository_tags.items():

            #chs = chs.split(':')[-1]

try:

    import json

except ImportError:

    #python 2.5 compatibility

    import simplejson as json

log = logging.getLogger(__name__)

class SummaryController(BaseController):

    @LoginRequired()

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

                                   'repository.admin')

    def __before__(self):

        super(SummaryController, self).__before__()

    def index(self):

        scm_model = ScmModel()

        c.repo_info = scm_model.get_repo(c.repo_name)

        c.following = scm_model.is_following_repo(c.repo_name,

                                             c.rhodecode_user.user_id)

        def url_generator(**kw):

            return url('shortlog_home', repo_name=c.repo_name, **kw)

        c.repo_changesets = Page(c.repo_info, page=1, items_per_page=10,

                                 url=url_generator)

        e = request.environ

        if self.rhodecode_user.username == 'default':

            #for default(anonymous) user we don't need to pass credentials

            username = ''

            password = ''

        else:

            username = str(c.rhodecode_user.username)

            password = '@'

        uri = u'%(protocol)s://%(user)s%(password)s%(host)s%(prefix)s/%(repo_name)s' % {

                                        'protocol': e.get('wsgi.url_scheme'),

                                        'user':username,

                                        'password':password,

                                        'host':e.get('HTTP_HOST'),

                                        'prefix':e.get('SCRIPT_NAME'),

                                        'repo_name':c.repo_name, }

        c.clone_repo_url = uri

        c.repo_tags = OrderedDict()

        for name, hash in c.repo_info.tags.items()[:10]:

            try:

                c.repo_tags[name] = c.repo_info.get_changeset(hash)

            except ChangesetError:

                c.repo_tags[name] = EmptyChangeset(hash)

        c.repo_branches = OrderedDict()

        for name, hash in c.repo_info.branches.items()[:10]:

            try:

                c.repo_branches[name] = c.repo_info.get_changeset(hash)

            except ChangesetError:

                c.repo_branches[name] = EmptyChangeset(hash)

        td = date.today() + timedelta(days=1)

        td_1m = td - timedelta(days=calendar.mdays[td.month])

        td_1y = td - timedelta(days=365)

        ts_min_m = mktime(td_1m.timetuple())

        ts_min_y = mktime(td_1y.timetuple())

        ts_max_y = mktime(td.timetuple())

        if c.repo_info.dbrepo.enable_statistics:

            c.no_data_msg = _('No data loaded yet')

            run_task(get_commits_stats, c.repo_info.name, ts_min_y, ts_max_y)

        else:

            c.no_data_msg = _('Statistics update are disabled for this repository')

        c.ts_min = ts_min_m

        c.ts_max = ts_max_y

        stats = self.sa.query(Statistics)\

            .filter(Statistics.repository == c.repo_info.dbrepo)\

            .scalar()

        if stats and stats.languages:

            c.no_data = False is c.repo_info.dbrepo.enable_statistics

            lang_stats = json.loads(stats.languages)

            c.commit_data = stats.commit_activity

            c.overview_data = stats.commit_activity_combined

            c.trending_languages = json.dumps(OrderedDict(

                                       sorted(lang_stats.items(), reverse=True,

                                            key=lambda k: k[1])[:10]

                                        )

                                    )

        else:

            c.commit_data = json.dumps({})

            c.overview_data = json.dumps([[ts_min_y, 0], [ts_max_y, 10] ])

            c.trending_languages = json.dumps({})

            c.no_data = True

        c.download_options = self._get_download_links(c.repo_info)

        return render('summary/summary.html')

    def _get_download_links(self, repo):

        download_l = []

        branches_group = ([], _("Branches"))

        tags_group = ([], _("Tags"))

        for name, chs in c.repository_branches.items():

            #chs = chs.split(':')[-1]

            branches_group[0].append((chs, name),)

        download_l.append(branches_group)

        for name, chs in c.repository_tags.items():

            #chs = chs.split(':')[-1]

            tags_group[0].append((chs, name),)

        download_l.append(tags_group)

        return download_l

    ui_key = Column("ui_key", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    ui_value = Column("ui_value", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    ui_active = Column("ui_active", Boolean(), nullable=True, unique=None, default=True)

class User(Base, BaseModel):

    __tablename__ = 'users'

    __table_args__ = (UniqueConstraint('username'), UniqueConstraint('email'), {'useexisting':True})

    user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    username = Column("username", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    password = Column("password", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    active = Column("active", Boolean(), nullable=True, unique=None, default=None)

    admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)

    name = Column("name", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    lastname = Column("lastname", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    email = Column("email", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)

    is_ldap = Column("is_ldap", Boolean(), nullable=False, unique=None, default=False)

    user_log = relation('UserLog', cascade='all')

    user_perms = relation('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')

    repositories = relation('Repository')

    user_followers = relation('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')

    @property

    def full_contact(self):

        return '%s %s <%s>' % (self.name, self.lastname, self.email)

    @property

    def is_admin(self):

        return self.admin

    def __repr__(self):

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

                                     self.user_id, self.username)

    def update_lastlogin(self):

        """Update user lastlogin"""

        try:

            session = Session.object_session(self)

            self.last_login = datetime.datetime.now()

            session.add(self)

            session.commit()

            log.debug('updated user %s lastlogin', self.username)

        except (DatabaseError,):

            session.rollback()

class UserLog(Base, BaseModel):

    __tablename__ = 'user_logs'

    __table_args__ = {'useexisting':True}

    user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    repository_id = Column("repository_id", Integer(length=None, convert_unicode=False, assert_unicode=None), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

    repository_name = Column("repository_name", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    user_ip = Column("user_ip", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    action = Column("action", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)

    user = relation('User')

    repository = relation('Repository')

class UsersGroup(Base, BaseModel):

    __tablename__ = 'users_groups'

    __table_args__ = {'useexisting':True}

    users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_name = Column("users_group_name", String(length=None, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)

    users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)

    members = relation('UsersGroupMember')

class UsersGroupMember(Base, BaseModel):

    __tablename__ = 'users_groups_members'

    __table_args__ = {'useexisting':True}

    users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    user = relation('User')

    users_group = relation('UsersGroup')

class Repository(Base, BaseModel):

    __tablename__ = 'repositories'

    __table_args__ = (UniqueConstraint('repo_name'), {'useexisting':True},)

    repo_id = Column("repo_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    repo_name = Column("repo_name", String(length=None, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)

    repo_type = Column("repo_type", String(length=None, convert_unicode=False, assert_unicode=None), nullable=False, unique=False, default='hg')

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)

    private = Column("private", Boolean(), nullable=True, unique=None, default=None)

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

    description = Column("description", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    fork_id = Column("fork_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=False, default=None)

    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=False, default=None)

    user = relation('User')

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

    group = relation('Group')

    repo_to_perm = relation('RepoToPerm', cascade='all')

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

    repo_followers = relation('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all')

    def __repr__(self):

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

                                  self.repo_id, self.repo_name)

class Group(Base, BaseModel):

    __tablename__ = 'groups'

    __table_args__ = (UniqueConstraint('group_name'), {'useexisting':True},)

    group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    group_name = Column("group_name", String(length=None, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)

    group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)

    parent_group = relation('Group', remote_side=group_id)

    def __init__(self, group_name='', parent_group=None):

        self.group_name = group_name

        self.parent_group = parent_group

    def __repr__(self):

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

                                  self.group_name)

class Permission(Base, BaseModel):

    __tablename__ = 'permissions'

    __table_args__ = {'useexisting':True}

    permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    permission_name = Column("permission_name", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    permission_longname = Column("permission_longname", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    def __repr__(self):

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

                                  self.permission_id, self.permission_name)

class RepoToPerm(Base, BaseModel):

    __tablename__ = 'repo_to_perm'

    __table_args__ = (UniqueConstraint('user_id', 'repository_id'), {'useexisting':True})

    repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

    user = relation('User')

    permission = relation('Permission')

    repository = relation('Repository')

class UserToPerm(Base, BaseModel):

    __tablename__ = 'user_to_perm'

    __table_args__ = (UniqueConstraint('user_id', 'permission_id'), {'useexisting':True})

    user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    user = relation('User')

    permission = relation('Permission')

class UsersGroupToPerm(Base, BaseModel):

    __tablename__ = 'users_group_to_perm'

    __table_args__ = (UniqueConstraint('users_group_id', 'permission_id'), {'useexisting':True})

    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    users_group = relation('UsersGroup')

    permission = relation('Permission')

class GroupToPerm(Base, BaseModel):

    __tablename__ = 'group_to_perm'

    __table_args__ = (UniqueConstraint('group_id', 'permission_id'), {'useexisting':True})

    group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

    user = relation('User')

    permission = relation('Permission')

    group = relation('Group')

class Statistics(Base, BaseModel):

    __tablename__ = 'statistics'

    __table_args__ = (UniqueConstraint('repository_id'), {'useexisting':True})

    stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)

        return value

#===============================================================================

# FORMS        

#===============================================================================

class LoginForm(formencode.Schema):

    allow_extra_fields = True

    filter_extra_fields = True

    username = UnicodeString(

                             strip=True,

                             min=1,

                             not_empty=True,

                             messages={

                                       'empty':_('Please enter a login'),

                                       'tooShort':_('Enter a value %(min)i characters long or more')}

                            )

    password = UnicodeString(

                            strip=True,

                            min=6,

                            not_empty=True,

                            messages={

                                      'empty':_('Please enter a password'),

                                      'tooShort':_('Enter %(min)i characters or more')}

                                )

    #chained validators have access to all data

    chained_validators = [ValidAuth]

def UserForm(edit=False, old_data={}):

    class _UserForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        username = All(UnicodeString(strip=True, min=1, not_empty=True),

                       ValidUsername(edit, old_data))

        if edit:

            new_password = All(UnicodeString(strip=True, min=6, not_empty=False))

            admin = StringBoolean(if_missing=False)

        else:

            password = All(UnicodeString(strip=True, min=6, not_empty=True))

        active = StringBoolean(if_missing=False)

        name = UnicodeString(strip=True, min=1, not_empty=True)

        lastname = UnicodeString(strip=True, min=1, not_empty=True)

        email = All(Email(not_empty=True), UniqSystemEmail(old_data))

        chained_validators = [ValidPassword]

    return _UserForm

def UsersGroupForm(edit=False, old_data={}):

    class _UsersGroupForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        users_group_name = All(UnicodeString(strip=True, min=1, not_empty=True),

                       ValidUsersGroup(edit, old_data))

        users_group_active = StringBoolean(if_missing=False)

    return _UsersGroupForm

def RegisterForm(edit=False, old_data={}):

    class _RegisterForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        username = All(ValidUsername(edit, old_data),

                       UnicodeString(strip=True, min=1, not_empty=True))

        password = All(UnicodeString(strip=True, min=6, not_empty=True))

        password_confirmation = All(UnicodeString(strip=True, min=6, not_empty=True))

        active = StringBoolean(if_missing=False)

        name = UnicodeString(strip=True, min=1, not_empty=True)

        lastname = UnicodeString(strip=True, min=1, not_empty=True)

        email = All(Email(not_empty=True), UniqSystemEmail(old_data))

        chained_validators = [ValidPasswordsMatch, ValidPassword]

    return _RegisterForm

def PasswordResetForm():

    class _PasswordResetForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        email = All(ValidSystemEmail(), Email(not_empty=True))

    return _PasswordResetForm

def RepoForm(edit=False, old_data={}, supported_backends=BACKENDS.keys()):

    class _RepoForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        repo_name = All(UnicodeString(strip=True, min=1, not_empty=True),

                        ValidRepoName(edit, old_data))

        description = UnicodeString(strip=True, min=1, not_empty=True)

        private = StringBoolean(if_missing=False)

        enable_statistics = StringBoolean(if_missing=False)

        repo_type = OneOf(supported_backends)

        if edit:

            user = All(Int(not_empty=True), ValidRepoUser)

        chained_validators = [ValidPerms]

    return _RepoForm

def RepoForkForm(edit=False, old_data={}, supported_backends=BACKENDS.keys()):

    class _RepoForkForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        fork_name = All(UnicodeString(strip=True, min=1, not_empty=True),

                        ValidRepoName(edit, old_data))

        description = UnicodeString(strip=True, min=1, not_empty=True)

        private = StringBoolean(if_missing=False)

        repo_type = All(ValidForkType(old_data), OneOf(supported_backends))

    return _RepoForkForm

def RepoSettingsForm(edit=False, old_data={}):

    class _RepoForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        repo_name = All(UnicodeString(strip=True, min=1, not_empty=True),

                        ValidRepoName(edit, old_data))

        description = UnicodeString(strip=True, min=1, not_empty=True)

        private = StringBoolean(if_missing=False)

        chained_validators = [ValidPerms, ValidSettings]

    return _RepoForm

def ApplicationSettingsForm():

    class _ApplicationSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        rhodecode_title = UnicodeString(strip=True, min=1, not_empty=True)

        rhodecode_realm = UnicodeString(strip=True, min=1, not_empty=True)

        rhodecode_ga_code = UnicodeString(strip=True, min=1, not_empty=False)

    return _ApplicationSettingsForm

def ApplicationUiSettingsForm():

    class _ApplicationUiSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = False

        web_push_ssl = OneOf(['true', 'false'], if_missing='false')

        paths_root_path = All(ValidPath(), UnicodeString(strip=True, min=1, not_empty=True))

        hooks_changegroup_update = OneOf(['True', 'False'], if_missing=False)

        hooks_changegroup_repo_size = OneOf(['True', 'False'], if_missing=False)

        hooks_pretxnchangegroup_push_logger = OneOf(['True', 'False'], if_missing=False)

        hooks_preoutgoing_pull_logger = OneOf(['True', 'False'], if_missing=False)

    return _ApplicationUiSettingsForm

def DefaultPermissionsForm(perms_choices, register_choices, create_choices):

    class _DefaultPermissionsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        overwrite_default = StringBoolean(if_missing=False)

        anonymous = OneOf(['True', 'False'], if_missing=False)

        default_perm = OneOf(perms_choices)

        default_register = OneOf(register_choices)

        default_create = OneOf(create_choices)

    return _DefaultPermissionsForm

def LdapSettingsForm():

    class _LdapSettingsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        pre_validators = [LdapLibValidator]

        ldap_active = StringBoolean(if_missing=False)

        ldap_host = UnicodeString(strip=True,)

        ldap_port = Number(strip=True,)

        ldap_ldaps = StringBoolean(if_missing=False)

        ldap_dn_user = UnicodeString(strip=True,)

        ldap_dn_pass = UnicodeString(strip=True,)

        ldap_base_dn = All(BaseDnValidator, UnicodeString(strip=True,))

    return _LdapSettingsForm

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

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

<%def name="title()">

    ${_('Edit repository')} ${c.repo_info.repo_name} - ${c.rhodecode_name}

</%def>

<%def name="breadcrumbs_links()">

    ${h.link_to(_('Admin'),h.url('admin_home'))} 

    » 

    ${h.link_to(_('Repositories'),h.url('repos'))} 

    »

    ${_('edit')} "${c.repo_name}"

</%def>

<%def name="page_nav()">

	${self.menu('admin')}

</%def>

<%def name="main()">

<div class="box box-left">

    <!-- box / title -->

    <div class="title">

        ${self.breadcrumbs()}      

    </div>

    ${h.form(url('repo', repo_name=c.repo_info.repo_name),method='put')}

    <div class="form">

        <!-- fields -->

        <div class="fields">

            <div class="field">

                <div class="label">

                    <label for="repo_name">${_('Name')}:</label>

                </div>

                <div class="input">

                    ${h.text('repo_name',class_="medium")}

                </div>

             </div>

            <div class="field">

                <div class="label">

                    <label for="repo_type">${_('Type')}:</label>

                </div>

                <div class="input">

                    ${h.select('repo_type','hg',c.backends,class_="medium")}

                </div>

             </div>             

            <div class="field">

                <div class="label label-textarea">

                    <label for="description">${_('Description')}:</label>

                </div>

                <div class="textarea text-area editor">

                    ${h.textarea('description',cols=23,rows=5)}

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="private">${_('Private')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('private',value="True")}

                </div>

            </div>

            <div class="field">

                <div class="label label-checkbox">

                    <label for="enable_statistics">${_('Enable statistics')}:</label>

                </div>

                <div class="checkboxes">

                    ${h.checkbox('enable_statistics',value="True")}

                </div>

            </div>             

            <div class="field">

                <div class="label">

                    <label for="user">${_('Owner')}:</label>

                </div>

                <div class="input input-small ac">

                    <div class="perm_ac">

                       ${h.text('user',class_='yui-ac-input')}

                       <div id="owner_container"></div>

                    </div>

                </div>

             </div>                

            <div class="field">

                <div class="label">

                    <label for="input">${_('Permissions')}:</label>

                </div>

                <div class="input">

                    <table id="permissions_manage">

                        <tr>

                            <td>${_('none')}</td>

                            <td>${_('read')}</td>

                            <td>${_('write')}</td>

                            <td>${_('admin')}</td>

                            <td>${_('user')}</td>

                            <td></td>

                        </tr>

                        %for r2p in c.repo_info.repo_to_perm:

                            %if r2p.user.username =='default' and c.repo_info.private:

                                <tr>

                                    <td colspan="4">

                                        <span class="private_repo_msg">

                                        ${_('private repository')}

                                        </span>

                                    </td>

                                    <td class="private_repo_msg">${r2p.user.username}</td>

                                </tr>

                            %else:

                            <tr id="id${id(r2p.user.username)}">

                                <td>${h.radio('perm_%s' % r2p.user.username,'repository.none')}</td>

                                <td>${h.radio('perm_%s' % r2p.user.username,'repository.read')}</td>

                                <td>${h.radio('perm_%s' % r2p.user.username,'repository.write')}</td>

                                <td>${h.radio('perm_%s' % r2p.user.username,'repository.admin')}</td>

                                <td>${r2p.user.username}</td>

                                <td>

                                  %if r2p.user.username !='default':

                                    <span class="delete_icon action_button" onclick="ajaxAction(${r2p.user.user_id},'${'id%s'%id(r2p.user.username)}')">

                                        <script type="text/javascript">

                                            function ajaxAction(user_id,field_id){

                                                var sUrl = "${h.url('delete_repo_user',repo_name=c.repo_name)}";

                                                var callback = { success:function(o){

                                                var tr = YAHOO.util.Dom.get(String(field_id));

                                                tr.parentNode.removeChild(tr);},failure:function(o){

                                                    alert("${_('Failed to remove user')}");},};

                                                var postData = '_method=delete&user_id='+user_id; 

                                                var request = YAHOO.util.Connect.asyncRequest('POST', sUrl, callback, postData);};

                                        </script>           

                                    </span>

                                  %endif                    

                                </td>

                            </tr>

                            %endif

                        %endfor

                        <tr id="add_perm_input">

                            <td>${h.radio('perm_new_user','repository.none')}</td>

                            <td>${h.radio('perm_new_user','repository.read')}</td>

                            <td>${h.radio('perm_new_user','repository.write')}</td>

                            <td>${h.radio('perm_new_user','repository.admin')}</td>

                            <td class='ac'>

                                <div class="perm_ac" id="perm_ac">

                                    ${h.text('perm_new_user_name',class_='yui-ac-input')}

                                    <div id="perm_container"></div>

                                </div>

                            </td>

                            <td></td>

                        </tr>

                        <tr>

                            <td colspan="6">

                                <span id="add_perm" class="add_icon" style="cursor: pointer;">

                                ${_('Add another user')}

                                </span>

                            </td>

                        </tr>

                    </table>             

             </div>

            <div class="buttons">

              ${h.submit('save','Save',class_="ui-button")}

              ${h.reset('reset','Reset',class_="ui-button")}