API Controller

    Each method needs to have USER as argument this is then based on given

    API_KEY propagated as instance of user object

    Preferably this should be first argument also

    Each function should also **raise** JSONRPCError for any

    errors that happens

    """

    @HasPermissionAllDecorator('hg.admin')

    def pull(self, apiuser, repo):

        """

        Dispatch pull action on given repo

        :param user:

        :param repo:

        """

        if Repository.is_valid(repo) is False:

            raise JSONRPCError('Unknown repo "%s"' % repo)

        try:

            ScmModel().pull_changes(repo, self.rhodecode_user.username)

            return 'Pulled from %s' % repo

        except Exception:

            raise JSONRPCError('Unable to pull changes from "%s"' % repo)

    @HasPermissionAllDecorator('hg.admin')

    def get_user(self, apiuser, username):

        """"

        Get a user by username

        :param apiuser

        :param username

        """

        user = User.get_by_username(username)

        if not user:

            return None

        return dict(id=user.user_id,

                        username=user.username,

                        firstname=user.name,

                        lastname=user.lastname,

                        email=user.email,

                        active=user.active,

                        admin=user.admin,

                        ldap=user.ldap_dn)

    @HasPermissionAllDecorator('hg.admin')

    def get_users(self, apiuser):

        """"

        Get all users

        :param apiuser

        """

        result = []

        for user in User.getAll():

            result.append(dict(id=user.user_id,

                                username=user.username,

                                firstname=user.name,

                                lastname=user.lastname,

                                email=user.email,

                                active=user.active,

                                admin=user.admin,

                                ldap=user.ldap_dn))

        return result

    @HasPermissionAllDecorator('hg.admin')

    def create_user(self, apiuser, username, password, firstname,

                    lastname, email, active=True, admin=False, ldap_dn=None):

        """

        Create new user

        :param apiuser:

        :param username:

        :param password:

        :param name:

        :param lastname:

        :param email:

        :param active:

        :param admin:

        :param ldap_dn:

        """

        if self.get_user(apiuser, username):

            raise JSONRPCError("user %s already exist" % username)

        try:

            return dict(msg='created new user %s' % username)

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create user %s' % username)

    @HasPermissionAllDecorator('hg.admin')

    def get_users_group(self, apiuser, group_name):

        """"

        Get users group by name

        :param apiuser

        :param group_name

        """

        users_group = UsersGroup.get_by_group_name(group_name)

        if not users_group:

            return None

        members = []

        for user in users_group.members:

            user = user.user

            members.append(dict(id=user.user_id,

                            username=user.username,

                            firstname=user.name,

                            lastname=user.lastname,

                            email=user.email,

                            active=user.active,

                            admin=user.admin,

                            ldap=user.ldap_dn))

        return dict(id=users_group.users_group_id,

                    name=users_group.users_group_name,

                    active=users_group.users_group_active,

                    members=members)

    @HasPermissionAllDecorator('hg.admin')

    def get_users_groups(self, apiuser):

        """"

        Get all users groups

        :param apiuser

        """

        result = []

        for users_group in UsersGroup.getAll():

            members = []

            for user in users_group.members:

                user = user.user

                members.append(dict(id=user.user_id,

                                username=user.username,

                                firstname=user.name,

                                lastname=user.lastname,

                                email=user.email,

                                active=user.active,

                                admin=user.admin,

                                ldap=user.ldap_dn))

            result.append(dict(id=users_group.users_group_id,

                                name=users_group.users_group_name,

                                active=users_group.users_group_active,

                                members=members))

        return result

    @HasPermissionAllDecorator('hg.admin')

    def create_users_group(self, apiuser, name, active=True):

        """

        Creates an new usergroup

        :param name:

        :param active:

        """

        if self.get_users_group(apiuser, name):

            raise JSONRPCError("users group %s already exist" % name)

        try:

            form_data = dict(users_group_name=name,

                             users_group_active=active)

            ug = UsersGroup.create(form_data)

            return dict(id=ug.users_group_id,

                        msg='created new users group %s' % name)

        except Exception:

            log.error(traceback.format_exc())

            raise JSONRPCError('failed to create group %s' % name)

    @HasPermissionAllDecorator('hg.admin')

    def add_user_to_users_group(self, apiuser, group_name, user_name):

        """"

        Add a user to a group

        :param apiuser

        :param group_name

        :param user_name

        """

        try: