:param admin:

        :param ldap_dn:

        :param password:

        """

        user = get_user_or_error(userid)

        # call function and store only updated arguments

        updates = {}

        def store_update(attr, name):

            if not isinstance(attr, Optional):

                updates[name] = attr

        try:

            store_update(username, 'username')

            store_update(password, 'password')

            store_update(email, 'email')

            store_update(firstname, 'name')

            store_update(lastname, 'lastname')

            store_update(active, 'active')

            store_update(admin, 'admin')

            store_update(ldap_dn, 'ldap_dn')

            user = UserModel().update_user(user, **updates)

            Session().commit()

            return dict(

                msg='updated user ID:%s %s' % (user.user_id, user.username),

                user=user.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to update user `%s`' % userid)

    @HasPermissionAllDecorator('hg.admin')

    def delete_user(self, apiuser, userid):

        """"

        Deletes an user

        :param apiuser:

        :param userid:

        """

        user = get_user_or_error(userid)

        try:

            UserModel().delete(userid)

            Session().commit()

            return dict(

                msg='deleted user ID:%s %s' % (user.user_id, user.username),

                user=None

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to delete ID:%s %s' % (user.user_id,

                                                              user.username))

    @HasPermissionAllDecorator('hg.admin')

    def get_users_group(self, apiuser, usersgroupid):

        """"

        Get users group by name or id

        :param apiuser:

        :param usersgroupid:

        """

        users_group = get_users_group_or_error(usersgroupid)

        data = users_group.get_api_data()

        members = []

        for user in users_group.members:

            user = user.user

            members.append(user.get_api_data())

        data['members'] = members

        return data

    @HasPermissionAllDecorator('hg.admin')

    def get_users_groups(self, apiuser):

        """"

        Get all users groups

        :param apiuser:

        """

        result = []

        for users_group in UsersGroupModel().get_all():

            result.append(users_group.get_api_data())

        return result

    @HasPermissionAllDecorator('hg.admin')

    def create_users_group(self, apiuser, group_name, active=Optional(True)):

        """

        Creates an new usergroup

        :param apiuser:

        :param group_name:

        :param active:

        """

        if UsersGroupModel().get_by_name(group_name):

            raise JSONRPCError("users group `%s` already exist" % group_name)

        try:

            active = Optional.extract(active)

            ug = UsersGroupModel().create(name=group_name, active=active)

            Session().commit()

            return dict(

                msg='created new users group `%s`' % group_name,

                users_group=ug.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create group `%s`' % group_name)

    @HasPermissionAllDecorator('hg.admin')

    def add_user_to_users_group(self, apiuser, usersgroupid, userid):

        """"

        Add a user to a users group

        :param apiuser:

        :param usersgroupid:

        :param userid:

        """

        user = get_user_or_error(userid)

        users_group = get_users_group_or_error(usersgroupid)

        try:

            ugm = UsersGroupModel().add_user_to_group(users_group, user)

            success = True if ugm != True else False

            msg = 'added member `%s` to users group `%s`' % (

                        user.username, users_group.users_group_name

                    )

            msg = msg if success else 'User is already in that group'

            Session().commit()

            return dict(

                success=success,

                msg=msg

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to add member to users group `%s`' % (

                    users_group.users_group_name

                )

            )

    @HasPermissionAllDecorator('hg.admin')

    def remove_user_from_users_group(self, apiuser, usersgroupid, userid):

        """

        Remove user from a group

        :param apiuser:

        :param usersgroupid:

        :param userid:

        """

        user = get_user_or_error(userid)

        users_group = get_users_group_or_error(usersgroupid)

        try:

            success = UsersGroupModel().remove_user_from_group(users_group,

                                                               user)

            msg = 'removed member `%s` from users group `%s`' % (

                        user.username, users_group.users_group_name

                    )

            msg = msg if success else "User wasn't in group"

            Session().commit()

            return dict(success=success, msg=msg)

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to remove member from users group `%s`' % (

                        users_group.users_group_name

                    )

            )

    def get_repo(self, apiuser, repoid):

        """"

        Get repository by name

        :param apiuser:

        :param repoid:

        """

        repo = get_repo_or_error(repoid)

        if HasPermissionAnyApi('hg.admin')(user=apiuser) is False:

            # check if we have admin permission for this repo !

            if HasRepoPermissionAnyApi('repository.admin')(user=apiuser,

                                            repo_name=repo.repo_name) is False:

                raise JSONRPCError('repository `%s` does not exist' % (repoid))

        members = []

        for user in repo.repo_to_perm:

            perm = user.permission.permission_name

            user = user.user

            user_data = user.get_api_data()

            user_data['type'] = "user"

            user_data['permission'] = perm

            members.append(user_data)

        for users_group in repo.users_group_to_perm:

            perm = users_group.permission.permission_name

            users_group = users_group.users_group

            users_group_data = users_group.get_api_data()

            users_group_data['type'] = "users_group"

            users_group_data['permission'] = perm

            members.append(users_group_data)

        data = repo.get_api_data()

        data['members'] = members

        return data

    def get_repos(self, apiuser):

        """"

        Get all repositories

        :param apiuser:

        """

        result = []

        if HasPermissionAnyApi('hg.admin')(user=apiuser) is False:

            repos = RepoModel().get_all_user_repos(user=apiuser)

        else:

            repos = RepoModel().get_all()

        for repo in repos:

            result.append(repo.get_api_data())

        return result

    @HasPermissionAllDecorator('hg.admin')

    def get_repo_nodes(self, apiuser, repoid, revision, root_path,

                       ret_type='all'):

        """

        returns a list of nodes and it's children

        for a given path at given revision. It's possible to specify ret_type

        to show only files or dirs

        :param apiuser:

        :param repoid: name or id of repository

        :param revision: revision for which listing should be done

        :param root_path: path from which start displaying

        :param ret_type: return type 'all|files|dirs' nodes

        """

        repo = get_repo_or_error(repoid)

        try:

            _d, _f = ScmModel().get_nodes(repo, revision, root_path,

                                          flat=False)

            _map = {

                'all': _d + _f,

                'files': _f,

                'dirs': _d,

            }

            return _map[ret_type]

        except KeyError:

            raise JSONRPCError('ret_type must be one of %s' % _map.keys())

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to get repo: `%s` nodes' % repo.repo_name

            )

    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')

    def create_repo(self, apiuser, repo_name, owner=Optional(OAttr('apiuser')),

                    repo_type=Optional('hg'),

                    description=Optional(''), private=Optional(False),

                    clone_uri=Optional(None), landing_rev=Optional('tip'),

                    enable_statistics=Optional(False),

                    enable_locking=Optional(False),

                    enable_downloads=Optional(False)):

        """

        Create repository, if clone_url is given it makes a remote clone

        if repo_name is within a group name the groups will be created

        automatically if they aren't present

        :param apiuser:

        :param repo_name:

        :param onwer:

        :param repo_type:

        :param description:

        :param private:

        :param clone_uri:

        :param landing_rev:

        """

        if HasPermissionAnyApi('hg.admin')(user=apiuser) is False:

            if not isinstance(owner, Optional):

                #forbid setting owner for non-admins

                raise JSONRPCError(

                    'Only RhodeCode admin can specify `owner` param'

                )

        if isinstance(owner, Optional):

            owner = apiuser.user_id

        owner = get_user_or_error(owner)

        if RepoModel().get_by_repo_name(repo_name):

            raise JSONRPCError("repo `%s` already exist" % repo_name)

        defs = RhodeCodeSetting.get_default_repo_settings(strip_prefix=True)

        if isinstance(private, Optional):

            private = defs.get('repo_private') or Optional.extract(private)

        if isinstance(repo_type, Optional):

            repo_type = defs.get('repo_type')

        if isinstance(enable_statistics, Optional):

            enable_statistics = defs.get('repo_enable_statistics')

        if isinstance(enable_locking, Optional):

            enable_locking = defs.get('repo_enable_locking')

        if isinstance(enable_downloads, Optional):

            enable_downloads = defs.get('repo_enable_downloads')

        clone_uri = Optional.extract(clone_uri)

        description = Optional.extract(description)

        landing_rev = Optional.extract(landing_rev)

        try:

            # create structure of groups and return the last group

            group = map_groups(repo_name)

            repo = RepoModel().create_repo(

                repo_name=repo_name,

                repo_type=repo_type,

                description=description,

                owner=owner,

                private=private,

                clone_uri=clone_uri,

                repos_group=group,

                landing_rev=landing_rev,

                enable_statistics=enable_statistics,

                enable_downloads=enable_downloads,

                enable_locking=enable_locking

            )

            Session().commit()

            return dict(

                msg="Created new repository `%s`" % (repo.repo_name),

                repo=repo.get_api_data()

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create repository `%s`' % repo_name)

    @HasPermissionAnyDecorator('hg.admin', 'hg.fork.repository')

    def fork_repo(self, apiuser, repoid, fork_name, owner=Optional(OAttr('apiuser')),

                  description=Optional(''), copy_permissions=Optional(False),

                  private=Optional(False), landing_rev=Optional('tip')):

        repo = get_repo_or_error(repoid)

        repo_name = repo.repo_name

        _repo = RepoModel().get_by_repo_name(fork_name)

        if _repo:

            type_ = 'fork' if _repo.fork else 'repo'

            raise JSONRPCError("%s `%s` already exist" % (type_, fork_name))

        if HasPermissionAnyApi('hg.admin')(user=apiuser):

            pass

        elif HasRepoPermissionAnyApi('repository.admin',

                                     'repository.write',

                                     'repository.read')(user=apiuser,

                                                        repo_name=repo.repo_name):

            if not isinstance(owner, Optional):

                #forbid setting owner for non-admins

                raise JSONRPCError(

                    'Only RhodeCode admin can specify `owner` param'

                )

        else:

            raise JSONRPCError('repository `%s` does not exist' % (repoid))

        if isinstance(owner, Optional):

            owner = apiuser.user_id

        owner = get_user_or_error(owner)

        try:

            # create structure of groups and return the last group

            group = map_groups(fork_name)

            form_data = dict(

                repo_name=fork_name,

                repo_name_full=fork_name,

                repo_group=group,

                repo_type=repo.repo_type,

                description=Optional.extract(description),

                private=Optional.extract(private),

                copy_permissions=Optional.extract(copy_permissions),

                landing_rev=Optional.extract(landing_rev),

                update_after_clone=False,

                fork_parent_id=repo.repo_id,

            )

            RepoModel().create_fork(form_data, cur_user=owner)

            return dict(

                msg='Created fork of `%s` as `%s`' % (repo.repo_name,

                                                      fork_name),

                success=True  # cannot return the repo data here since fork

                              # cann be done async

            )

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError(

                'failed to fork repository `%s` as `%s`' % (repo_name,

                                                            fork_name)

            )

    def delete_repo(self, apiuser, repoid):

        """