:param created_on:

     :param enable_downloads:

     :param repo_id:

     :param enable_statistics:

     :param clone_uri:

     :param fork_id:

     :param created_on:

     :param enable_downloads:

     :param repo_id:

     :param enable_statistics:

     :param clone_uri:

     :param fork_id:

        else:

            admin = True

            repos_list = Session().query(Repository) \

                                 self.authuser.user_id).all()

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

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

            })

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

            })

        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)

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

            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)

        if pull_request.is_closed():

            return False

        reviewer = PullRequestReviewers.query() \

            .filter(PullRequestReviewers.pull_request == pull_request) \

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

        c.my_pull_requests = PullRequest.query(

            include_closed=c.closed,

            sorted=True,

        c.participate_in_pull_requests = []

        c.participate_in_pull_requests_todo = []

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

    # 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

        cur_perm = permissions[RK][r_k]

            # set admin if owner

            p = 'repository.admin'

        else:

        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

     'created_on',

     'enable_downloads',

     'repo_id',

     'enable_statistics',

     'clone_uri',

     'fork_id',

     'created_on',

     'enable_downloads',

     'repo_id',

     'enable_statistics',

     'clone_uri',

     'fork_id',

                      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)

            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,

    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?

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

            group_name=user_group.users_group_name,

            group_description=user_group.user_group_description,

            active=user_group.users_group_active,

        )

        if with_members:

            members = []

    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)

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

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

            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,

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

            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

    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)

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

        def repo_actions(repo_name):

            return _render('repo_actions', repo_name, super_user_actions)

        repos_data = []

        for repo in repos_list:

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

                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:

        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'])

            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

    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)

            # 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')

                    # 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:

    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

    (_('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:

            </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>

        // autocomplete

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

    });

</script>

 elems = [

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

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

    ]

%>

%for dt, dd, tt in elems:

    % 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>

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

                  <div style="float:left;">

                    ${member.full_name_and_username}

                      (${_('Owner')})

                    %endif

                  </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}"

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

          <ul>

            <li>

              </a>

            </li>

            <li>

    gist_mapping = {

        f_name: {'content': content}

    }

                       gist_mapping=gist_mapping, gist_type=gist_type,

                       lifetime=lifetime)

    Session().commit()

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

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

    def test_my_account_my_repos(self):

        self.log_user()

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

                           User.get_by_username(TEST_USER_ADMIN_LOGIN)).count()

        response.mustcontain('"totalRecords": %s' % cnt)