@@ -458,96 +458,119 @@ INPUT::
"revision" : "<revision>",
"root_path" : "<root_path>",
"ret_type" : "<ret_type>" = 'all'
}
OUTPUT::
result: [
{
"name" : "<name>"
"type" : "<type>",
},
…
]
error: null
create_repo
-----------
Creates a repository. This command can be executed only using api_key
belonging to user with admin rights.
If repository name contains "/", all needed repository groups will be created.
For example "foo/bar/baz" will create groups "foo", "bar" (with "foo" as parent),
and create "baz" repository with "bar" as group.
INPUT::
api_key : "<api_key>"
method : "create_repo"
args: {
"repo_name" : "<reponame>",
"owner_name" : "<ownername>",
"description" : "<description> = ''",
"repo_type" : "<type> = 'hg'",
"private" : "<bool> = False"
result: {
"id": "<newrepoid>",
"msg": "Created new repository <reponame>",
delete_repo
Deletes a repository. This command can be executed only using api_key
method : "delete_repo"
"msg": "Deleted repository <reponame>",
grant_user_permission
---------------------
Grant permission for user on given repository, or update existing one
if found. This command can be executed only using api_key belonging to user
with admin rights.
method : "grant_user_permission"
"username" : "<username>",
"perm" : "(repository.(none|read|write|admin))",
"msg" : "Granted perm: <perm> for user: <username> in repo: <reponame>"
revoke_user_permission
----------------------
Revoke permission for user on given repository. This command can be executed
only using api_key belonging to user with admin rights.
method : "revoke_user_permission"
"msg" : "Revoked perm for user: <suername> in repo: <reponame>"
@@ -448,96 +448,115 @@ class ApiController(JSONRPCController):
:param description:
:param type:
:param private:
:param owner_name:
"""
try:
owner = User.get_by_username(owner_name)
if owner is None:
raise JSONRPCError('unknown user %s' % owner_name)
if Repository.get_by_repo_name(repo_name):
raise JSONRPCError("repo %s already exist" % repo_name)
groups = repo_name.split('/')
real_name = groups[-1]
groups = groups[:-1]
parent_id = None
for g in groups:
group = RepoGroup.get_by_group_name(g)
if not group:
group = ReposGroupModel().create(g, '', parent_id)
parent_id = group.group_id
repo = RepoModel().create(
dict(
repo_name=real_name,
repo_name_full=repo_name,
description=description,
private=private,
repo_type=repo_type,
repo_group=parent_id,
clone_uri=None
),
owner
)
Session.commit()
return dict(
id=repo.repo_id,
msg="Created new repository %s" % repo.repo_name
except Exception:
log.error(traceback.format_exc())
raise JSONRPCError('failed to create repository %s' % repo_name)
@HasPermissionAnyDecorator('hg.admin')
def delete_repo(self, apiuser, repo_name):
Deletes a given repository
:param repo_name:
if not Repository.get_by_repo_name(repo_name):
raise JSONRPCError("repo %s does not exist" % repo_name)
RepoModel().delete(repo_name)
msg='Deleted repository %s' % repo_name
raise JSONRPCError('failed to delete repository %s' % repo_name)
def grant_user_permission(self, repo_name, username, perm):
if found
:param username:
:param perm:
repo = Repository.get_by_repo_name(repo_name)
if repo is None:
raise JSONRPCError('unknown repository %s' % repo)
user = User.get_by_username(username)
if user is None:
raise JSONRPCError('unknown user %s' % username)
RepoModel().grant_user_permission(repo=repo, user=user, perm=perm)
msg='Granted perm: %s for user: %s in repo: %s' % (
perm, username, repo_name
raise JSONRPCError(
'failed to edit permission %(repo)s for %(user)s' % dict(
user=username, repo=repo_name
def revoke_user_permission(self, repo_name, username):
Revoke permission for user on given repository
@@ -257,96 +257,97 @@ class RepoModel(BaseModel):
self.sa.add(repo_to_perm)
if fork:
if form_data.get('copy_permissions'):
repo = Repository.get(fork_parent_id)
user_perms = UserRepoToPerm.query()\
.filter(UserRepoToPerm.repository == repo).all()
group_perms = UsersGroupRepoToPerm.query()\
.filter(UsersGroupRepoToPerm.repository == repo).all()
for perm in user_perms:
UserRepoToPerm.create(perm.user, new_repo,
perm.permission)
for perm in group_perms:
UsersGroupRepoToPerm.create(perm.users_group, new_repo,
else:
_create_default_perms()
if not just_db:
self.__create_repo(repo_name, form_data['repo_type'],
form_data['repo_group'],
form_data['clone_uri'])
# now automatically start following this repository as owner
ScmModel(self.sa).toggle_following_repo(new_repo.repo_id,
cur_user.user_id)
log_create_repository(new_repo.get_dict(),
created_by=cur_user.username)
return new_repo
except:
raise
def create_fork(self, form_data, cur_user):
Simple wrapper into executing celery task for fork creation
:param form_data:
:param cur_user:
from rhodecode.lib.celerylib import tasks, run_task
run_task(tasks.create_repo_fork, form_data, cur_user)
def delete(self, repo):
repo = self.__get_repo(repo)
self.sa.delete(repo)
self.__delete_repo(repo)
def grant_user_permission(self, repo, user, perm):
:param repo: Instance of Repository, repository_id, or repository name
:param user: Instance of User, user_id or username
:param perm: Instance of Permission, or permission_name
user = self.__get_user(user)
permission = self.__get_perm(perm)
# check if we have that permission already
obj = self.sa.query(UserRepoToPerm)\
.filter(UserRepoToPerm.user == user)\
.filter(UserRepoToPerm.repository == repo)\
.scalar()
if obj is None:
# create new !
obj = UserRepoToPerm()
obj.repository = repo
obj.user = user
obj.permission = permission
self.sa.add(obj)
def revoke_user_permission(self, repo, user):
.one()
self.sa.delete(obj)
Status change: