:param repo_type:

     :param description:

     :param private:

     :param created_on:

     :param enable_downloads:

     :param repo_id:

     :param enable_statistics:

     :param clone_uri:

     :param fork_id:

     :param group_id:

     :param created_by:

    """

     :param repo_type:

     :param description:

     :param private:

     :param created_on:

     :param enable_downloads:

     :param repo_id:

     :param enable_statistics:

     :param clone_uri:

     :param fork_id:

     :param group_id:

     :param deleted_by:

     :param deleted_on:

                         .join(UserFollowing) \

                         .filter(UserFollowing.user_id ==

                                 self.authuser.user_id).all()

        else:

            admin = True

            repos_list = Session().query(Repository) \

                                 self.authuser.user_id).all()

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

                                                   admin=admin)

        #json used to render the grid

        return json.dumps(repos_data)

            repo_count = repo_gr.repositories.count()

            repo_groups_data.append({

                "raw_name": repo_gr.group_name,

                "group_name": repo_group_name(repo_gr.group_name, children_groups),

                "desc": h.escape(repo_gr.group_description),

                "repos": repo_count,

                "action": repo_group_actions(repo_gr.group_id, repo_gr.group_name,

                                             repo_count)

            })

        c.data = json.dumps({

            "totalRecords": total_records,

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

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

            })

        c.data = json.dumps({

            "totalRecords": total_records,

            "startIndex": 0,

        if not isinstance(owner, Optional):

            owner = get_user_or_error(owner)

        updates = {}

        store_update(updates, group_name, 'users_group_name')

        store_update(updates, description, 'user_group_description')

        store_update(updates, active, 'users_group_active')

        try:

            UserGroupModel().update(user_group, updates)

            Session().commit()

            return dict(

                msg='updated user group ID:%s %s' % (user_group.users_group_id,

        if not isinstance(repo_group, Optional):

            repo_group = get_repo_group_or_error(repo_group)

            repo_group = repo_group.group_id

        try:

            store_update(updates, name, 'repo_name')

            store_update(updates, repo_group, 'repo_group')

            store_update(updates, description, 'repo_description')

            store_update(updates, private, 'repo_private')

            store_update(updates, clone_uri, 'clone_uri')

            store_update(updates, landing_rev, 'repo_landing_rev')

            store_update(updates, enable_statistics, 'repo_enable_statistics')

            store_update(updates, enable_locking, 'repo_enable_locking')

        c.journal_day_aggregate = self._get_daily_aggregate(c.journal_pager)

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

            return render('journal/journal_data.html')

        repos_list = Repository.query(sorted=True) \

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

                                                   admin=True)

        #json used to render the grid

        c.data = json.dumps(repos_data)

        return [g for g in groups if g[0]], selected

    def _get_is_allowed_change_status(self, pull_request):

        if pull_request.is_closed():

            return False

        reviewer = PullRequestReviewers.query() \

            .filter(PullRequestReviewers.pull_request == pull_request) \

            .filter(PullRequestReviewers.user_id == self.authuser.user_id) \

            .count() != 0

        return self.authuser.admin or owner or reviewer

    def show_my(self):

        c.closed = request.GET.get('closed') or ''

        c.my_pull_requests = PullRequest.query(

            include_closed=c.closed,

            sorted=True,

        c.participate_in_pull_requests = []

        c.participate_in_pull_requests_todo = []

        done_status = set([ChangesetStatus.STATUS_APPROVED, ChangesetStatus.STATUS_REJECTED])

        for pr in PullRequest.query(

            include_closed=c.closed,

    def post(self, repo_name, pull_request_id):

        pull_request = PullRequest.get_or_404(pull_request_id)

        if pull_request.is_closed():

            raise HTTPForbidden()

        assert pull_request.other_repo.repo_name == repo_name

        #only owner or admin can update it

        repo_admin = h.HasRepoPermissionAny('repository.admin')(c.repo_name)

        if not (h.HasPermissionAny('hg.admin')() or repo_admin or owner):

            raise HTTPForbidden()

        _form = PullRequestPostForm()().to_python(request.POST)

        reviewers_ids = [int(s) for s in _form['review_members']]

    for perm in default_global_perms:

        permissions[GLOBAL].add(perm.permission.permission_name)

    # defaults for repositories, taken from default user

    for perm in default_repo_perms:

        r_k = perm.UserRepoToPerm.repository.repo_name

            # disable defaults for private repos,

            p = 'repository.none'

            # set admin if owner

            p = 'repository.admin'

        else:

            p = perm.Permission.permission_name

        permissions[RK][r_k] = p

    for perm in user_repo_perms_from_users_groups:

        r_k = perm.UserGroupRepoToPerm.repository.repo_name

        multiple_counter[r_k] += 1

        p = perm.Permission.permission_name

        cur_perm = permissions[RK][r_k]

            # set admin if owner

            p = 'repository.admin'

        else:

            if multiple_counter[r_k] > 1:

                p = _choose_perm(p, cur_perm)

        permissions[RK][r_k] = p

    # by the group permission

    user_repo_perms = Permission.get_default_perms(user_id)

    for perm in user_repo_perms:

        r_k = perm.UserRepoToPerm.repository.repo_name

        cur_perm = permissions[RK][r_k]

        # set admin if owner

            p = 'repository.admin'

        else:

            p = perm.Permission.permission_name

            if not explicit:

                p = _choose_perm(p, cur_perm)

        permissions[RK][r_k] = p

     'repo_type',

     'description',

     'private',

     'created_on',

     'enable_downloads',

     'repo_id',

     'enable_statistics',

     'clone_uri',

     'fork_id',

     'group_id',

     'repo_name'

     'repo_type',

     'description',

     'private',

     'created_on',

     'enable_downloads',

     'repo_id',

     'enable_statistics',

     'clone_uri',

     'fork_id',

     'group_id',

     'repo_name'

        if group is None:

            log.debug('creating group level: %s group_name: %s',

                      lvl, group_name)

            group = RepoGroup(group_name, parent)

            group.group_description = desc

            sa.add(group)

            perm_obj = rgm._create_default_perms(group)

            sa.add(perm_obj)

            sa.flush()

        parent = group

            recipients = ChangesetComment.get_users(revision=revision)

            # add changeset author if it's known locally

            cs_author = User.get_from_cs_author(cs.author)

            if not cs_author:

                #use repo owner if we cannot extract the author correctly

                # FIXME: just use committer name even if not a user

            recipients += [cs_author]

            email_kwargs = {

                'status_change': status_change,

                'cs_comment_user': user.full_name_and_username,

                'cs_target_repo': h.canonical_url('summary_home', repo_name=repo.repo_name),

                'cs_comment_url': comment_url,

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

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

    user_group_description = Column(Unicode(10000), nullable=True) # FIXME: not nullable?

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

    inherit_default_permissions = Column("users_group_inherit_default_permissions", Boolean(), nullable=False, default=True)

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

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

    members = relationship('UserGroupMember', cascade="all, delete-orphan")

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

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

    users_group_repo_group_to_perm = relationship('UserGroupRepoGroupToPerm', cascade='all')

    user_user_group_to_perm = relationship('UserUserGroupToPerm ', cascade='all')

    user_group_user_group_to_perm = relationship('UserGroupUserGroupToPerm ', primaryjoin="UserGroupUserGroupToPerm.target_user_group_id==UserGroup.users_group_id", cascade='all')

    @hybrid_property

    def group_data(self):

        if not self._group_data:

            return {}

        data = dict(

            users_group_id=user_group.users_group_id,

            group_name=user_group.users_group_name,

            group_description=user_group.user_group_description,

            active=user_group.users_group_active,

        )

        if with_members:

            members = []

            for user in user_group.members:

                user = user.user

                members.append(user.get_api_data())

    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?

    repo_type = Column(String(255), 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)

    _locked = Column("locked", String(255), nullable=True) # FIXME: not nullable?

    _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)

    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)

        return cls.url_sep().join(repo_name.split(os.sep))

    @classmethod

    def get_by_repo_name(cls, repo_name):

        q = Session().query(cls).filter(cls.repo_name == repo_name)

        q = q.options(joinedload(Repository.fork)) \

                .options(joinedload(Repository.group))

        return q.scalar()

    @classmethod

    def get_by_full_path(cls, repo_full_path):

        base_full_path = os.path.realpath(cls.base_path())

            repo_type=repo.repo_type,

            clone_uri=repo.clone_uri,

            private=repo.private,

            created_on=repo.created_on,

            description=repo.description,

            landing_rev=repo.landing_rev,

            fork_of=repo.fork.repo_name if repo.fork else None,

            enable_statistics=repo.enable_statistics,

            enable_locking=repo.enable_locking,

            enable_downloads=repo.enable_downloads,

            last_changeset=repo.changeset_cache,

            locked_by=User.get(self.locked[0]).get_api_data() \

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

    group_name = Column(Unicode(255), nullable=False, unique=True) # full path

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

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

    enable_locking = Column(Boolean(), nullable=False, default=False)

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

    repo_group_to_perm = relationship('UserRepoGroupToPerm', cascade='all', order_by='UserRepoGroupToPerm.group_to_perm_id')

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

    parent_group = relationship('RepoGroup', remote_side=group_id)

    @classmethod

    def query(cls, sorted=False):

        """Add RepoGroup-specific helpers for common query constructs.

        sorted: if True, apply the default ordering (name, case insensitive).

        data = dict(

            group_id=group.group_id,

            group_name=group.group_name,

            group_description=group.group_description,

            parent_group=group.parent_group.group_name if group.parent_group else None,

            repositories=[x.repo_name for x in group.repositories],

        )

        return data

class Permission(Base, BaseModel):

    __tablename__ = 'permissions'

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

    title = Column(Unicode(255), nullable=False)

    description = Column(UnicodeText(), nullable=False)

    status = Column(Unicode(255), nullable=False, default=STATUS_NEW) # only for closedness, not approve/reject/etc

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

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

    _revisions = Column('revisions', UnicodeText(), nullable=False)

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

    org_ref = Column(Unicode(255), nullable=False)

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

    other_ref = Column(Unicode(255), nullable=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:

            # Not a real field - just for reference for validation:

            # clone_uri_hidden = v.UnicodeString(if_missing='')

        chained_validators = [v.ValidCloneUri(),

                              v.ValidRepoName(edit, old_data)]

    return _RepoForm

        def state(repo_state):

            return _render("repo_state", repo_state)

        def repo_actions(repo_name):

            return _render('repo_actions', repo_name, super_user_actions)

        repos_data = []

        for repo in repos_list:

            if perm_check:

                # check permission at this level

                if not HasRepoPermissionAny(

                                 repo.repo_state, repo.private, repo.fork),

                "last_change_iso": repo.last_db_change.isoformat(),

                "last_change": last_change(repo.last_db_change),

                "last_changeset": last_rev(repo.repo_name, cs_cache),

                "last_rev_raw": cs_cache.get('revision'),

                "desc": desc(repo.description),

                "state": state(repo.repo_state),

                "rss": rss_lnk(repo.repo_name),

                "atom": atom_lnk(repo.repo_name),

            }

            if admin:

                row.update({

                    "action": repo_actions(repo.repo_name),

                })

            repos_data.append(row)

        return {

            "totalRecords": len(repos_list),

            "startIndex": 0,

                val = ':'.join(defaults[attr])

            defaults[k] = val

            if k == 'clone_uri':

                defaults['clone_uri_hidden'] = repo_info.clone_uri_hidden

        # fill owner

        else:

            replacement_user = User.query().filter(User.admin ==

                                                   True).first().username

        # fill repository users

        for p in repo_info.repo_to_perm:

            defaults.update({'u_perm_%s' % p.user.username:

                                 p.permission.permission_name})

        return defaults

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

        try:

            cur_repo = self._get_repo(repo)

            org_repo_name = cur_repo.repo_name

            if 'repo_group' in kwargs:

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

                cur_repo.repo_name = cur_repo.get_new_name(cur_repo.just_name)

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

            for k in ['repo_enable_downloads',

            new_repo = Repository()

            new_repo.repo_state = state

            new_repo.enable_statistics = False

            new_repo.repo_name = repo_name_full

            new_repo.repo_type = repo_type

            new_repo.group = repo_group

            new_repo.description = description or repo_name

            new_repo.private = private

            new_repo.clone_uri = clone_uri

            new_repo.landing_rev = landing_rev

                                          group.name)

                shutil.move(rm_path, os.path.join(self.repos_path, _d))

    def create(self, group_name, group_description, owner, parent=None,

               just_db=False, copy_permissions=False):

        try:

            parent_group = self._get_repo_group(parent)

            new_repo_group = RepoGroup()

            new_repo_group.group_description = group_description or group_name

            new_repo_group.parent_group = parent_group

            new_repo_group.group_name = new_repo_group.get_new_name(group_name)

            self.sa.add(new_repo_group)

            # create an ADMIN permission for owner except if we're super admin,

            # later owner should go into the owner field of groups

                self.grant_user_permission(repo_group=new_repo_group,

                                           user=owner, perm='group.admin')

            if parent_group and copy_permissions:

                # copy permissions from parent

                user_perms = UserRepoGroupToPerm.query() \

                    .filter(UserGroupRepoGroupToPerm.group == parent_group).all()

                for perm in user_perms:

                    # don't copy over the permission for user who is creating

                    # this group, if he is not super admin he get's admin

                    # permission set above

                        UserRepoGroupToPerm.create(perm.user, new_repo_group, perm.permission)

                for perm in group_perms:

                    UserGroupRepoGroupToPerm.create(perm.users_group, new_repo_group, perm.permission)

            else:

                perm_obj = self._create_default_perms(new_repo_group)

    def get_by_name(self, name, cache=False, case_insensitive=False):

        return UserGroup.get_by_group_name(name, cache, case_insensitive)

    def create(self, name, description, owner, active=True, group_data=None):

        try:

            new_user_group = UserGroup()

            new_user_group.users_group_name = name

            new_user_group.user_group_description = description

            new_user_group.users_group_active = active

            if group_data:

                new_user_group.group_data = group_data

            self.sa.add(new_user_group)

<%

 elems = [

    (_('Top level repositories'), c.repo_group.repositories.count(), ''),

    (_('Total repositories'), c.repo_group.repositories_recursive_count, ''),

    (_('Children groups'), c.repo_group.children.count(), ''),

    (_('Created on'), h.fmt_date(c.repo_group.created_on), ''),

 ]

%>

%for dt, dd, tt in elems:

  <dt style="width:150px; text-align: left">${dt}:</dt>

  <dd style="margin-left: 160px" title="${tt}">${dd}</dd>

%endfor

                    ${h.select('repo_landing_rev','',c.landing_revs,class_="medium")}

                    <span class="help-block">${_('Default revision for files page, downloads, whoosh and readme')}</span>

                </div>

            </div>

            <div class="field">

                <div class="label">

                </div>

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

                    <div class="perm_ac">

                       <span class="help-block">${_('Change owner of this repository.')}</span>

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

                    </div>

                </div>

             </div>

            <div class="field">

        $('#repo_group').select2({

            'dropdownAutoWidth': true

        });

        // autocomplete

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

    });

</script>

<dl class="dl-horizontal">

<%

 elems = [

    (_('Members'), len(c.group_members_obj), ''),

    (_('Created on'), h.fmt_date(c.user_group.created_on), ''),

    ]

%>

%for dt, dd, tt in elems:

  <dt style="width:150px; text-align: left">${dt}:</dt>

  <dd style="margin-left: 160px" title="${tt}">${dd}</dd>

%endfor

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

% if c.forks_pager:

    % for f in c.forks_pager:

        <div>

            <div class="fork_user">

                <span style="font-size: 20px">

                  ${h.link_to(f.repo_name,h.url('summary_home',repo_name=f.repo_name))}

                </span>

                <div style="padding:5px 3px 3px 42px;">${f.description}</div>

            </div>

            <div style="clear:both;padding-top: 10px"></div>

            <div class="follower_date">${_('Forked')} -

                    <div class="reviewer_status tooltip" title="${h.changeset_status_lbl(status)}">

                      <i class="icon-circle changeset-status-${status}"></i>

                    </div>

                  ${h.gravatar_div(member.email, size=14, div_class="reviewer_gravatar gravatar")}

                  <div style="float:left;">

                    ${member.full_name_and_username}

                      (${_('Owner')})

                    %endif

                  </div>

                  <input type="hidden" value="${member.user_id}" name="review_members" />

                  %if editable:

                  <div class="reviewer_member_remove action_button" onclick="removeReviewMember(${member.user_id})" title="${_('Remove reviewer')}">

        <div class="pr-details-title">${_('Potential Reviewers')}</div>

        <div style="margin: 10px 0 10px 10px; max-width: 250px">

          <div>

            ${_('Click to add the repository owner as reviewer:')}

          </div>

          <ul style="margin-top: 10px">

              <li>

                <a class="missing_reviewer missing_reviewer_${u.user_id}"

                  user_id="${u.user_id}"

                  fname="${u.name}"

                  lname="${u.lastname}"

                  nname="${u.username}"

              </div>

            </div>

        </div>

        <div id="summary-menu-stats">

          <ul>

            <li>

              </a>

            </li>

            <li>

               <a title="${_('Followers')}" href="${h.url('repo_followers_home',repo_name=c.repo_name)}">

                <i class="icon-heart"></i> ${_('Followers')}

                <span class="badge" id="current_followers_count">${c.repository_followers}</span>

def _create_gist(f_name, content='some gist', lifetime=-1,

                 description=u'gist-desc', gist_type='public',

                 owner=TEST_USER_ADMIN_LOGIN):

    gist_mapping = {

        f_name: {'content': content}

    }

                       gist_mapping=gist_mapping, gist_type=gist_type,

                       lifetime=lifetime)

    Session().commit()

    return gist

        assert Repository.get_by_repo_name(self.REPO).private == False

        response = self.app.post(url('update_repo', repo_name=self.REPO),

                        fixture._get_repo_create_params(repo_private=1,

                                                repo_name=self.REPO,

                                                repo_type=self.REPO_TYPE,

                                                _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               msg='Repository %s updated successfully' % (self.REPO))

        assert Repository.get_by_repo_name(self.REPO).private == True

        #now the repo default permission should be None

        assert perm[0].permission.permission_name == 'repository.none'

        response = self.app.post(url('update_repo', repo_name=self.REPO),

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=self.REPO,

                                                repo_type=self.REPO_TYPE,

                                                _authentication_token=self.authentication_token()))

        self.checkSessionFlash(response,

                               msg='Repository %s updated successfully' % (self.REPO))

        assert Repository.get_by_repo_name(self.REPO).private == False

        #we turn off private now the repo default permission should stay None

        response.mustcontain('value="%s' % TEST_USER_ADMIN_LOGIN)

    def test_my_account_my_repos(self):

        self.log_user()

        response = self.app.get(url('my_account_repos'))