settings: Add spec and stubs for ListRoleAssignmentsFiltered request

services/settings/pkg/service/v0/service.go

@@ -342,6 +342,28 @@ func (g Service) ListRoleAssignments(ctx context.Context, req *settingssvc.ListR
 	return nil
 }
 
+func (g Service) ListRoleAssignmentsFiltered(ctx context.Context, req *settingssvc.ListRoleAssignmentsFilteredRequest, res *settingssvc.ListRoleAssignmentsResponse) error {
+	if validationError := validateListRoleAssignmentsFiltered(req); validationError != nil {
+		return merrors.BadRequest(g.id, "%s", validationError)
+	}
+	filters := req.GetFilters()
+
+	var r []*settingsmsg.UserRoleAssignment
+	var err error
+	switch filters[0].GetType() {
+	case settingsmsg.UserRoleAssignmentFilter_TYPE_ACCOUNT:
+		accountUUID := getValidatedAccountUUID(ctx, filters[0].GetAccountUuid())
+		r, err = g.manager.ListRoleAssignments(accountUUID)
+	case settingsmsg.UserRoleAssignmentFilter_TYPE_ROLE:
+		err = fmt.Errorf("filtering by role not implemented")
+	}
+	if err != nil {
+		return merrors.NotFound(g.id, "%s", err)
+	}
+	res.Assignments = r
+	return nil
+}
+
 // AssignRoleToUser implements the RoleServiceHandler interface
 func (g Service) AssignRoleToUser(ctx context.Context, req *settingssvc.AssignRoleToUserRequest, res *settingssvc.AssignRoleToUserResponse) error {
 	req.AccountUuid = getValidatedAccountUUID(ctx, req.AccountUuid)

services/settings/pkg/service/v0/service_test.go

@@ -234,3 +234,105 @@ func TestListPermissionsOfOtherUser(t *testing.T) {
 	assert.Equal(t, int32(http.StatusNotFound), merr.Code)
 	assert.Contains(t, err.Error(), req.AccountUuid)
 }
+
+func TestListRoleAssignmentsFiltered(t *testing.T) {
+	manager := &mocks.Manager{}
+	svc := Service{
+		manager: manager,
+	}
+
+	tests := map[string]struct {
+		req        *v0.ListRoleAssignmentsFilteredRequest
+		statusCode int32
+	}{
+		"no filters": {
+			req:        &v0.ListRoleAssignmentsFilteredRequest{},
+			statusCode: http.StatusBadRequest,
+		},
+		"multiple filters": {
+			req: &v0.ListRoleAssignmentsFilteredRequest{
+				Filters: []*settingsmsg.UserRoleAssignmentFilter{
+					{
+						Type: settingsmsg.UserRoleAssignmentFilter_TYPE_ACCOUNT,
+						Term: &settingsmsg.UserRoleAssignmentFilter_AccountUuid{
+							AccountUuid: "uid",
+						},
+					},
+					{
+						Type: settingsmsg.UserRoleAssignmentFilter_TYPE_ROLE,
+						Term: &settingsmsg.UserRoleAssignmentFilter_RoleId{
+							RoleId: "rid",
+						},
+					},
+				},
+			},
+			statusCode: http.StatusBadRequest,
+		},
+		"bad filtertype": {
+			req: &v0.ListRoleAssignmentsFilteredRequest{
+				Filters: []*settingsmsg.UserRoleAssignmentFilter{
+					{
+						Type: settingsmsg.UserRoleAssignmentFilter_TYPE_UNKNOWN,
+					},
+				},
+			},
+			statusCode: http.StatusBadRequest,
+		},
+		"account filter without term": {
+			req: &v0.ListRoleAssignmentsFilteredRequest{
+				Filters: []*settingsmsg.UserRoleAssignmentFilter{
+					{
+						Type: settingsmsg.UserRoleAssignmentFilter_TYPE_ACCOUNT,
+					},
+				},
+			},
+			statusCode: http.StatusBadRequest,
+		},
+		"account filter with invalid term": {
+			req: &v0.ListRoleAssignmentsFilteredRequest{
+				Filters: []*settingsmsg.UserRoleAssignmentFilter{
+					{
+						Type: settingsmsg.UserRoleAssignmentFilter_TYPE_ACCOUNT,
+						Term: &settingsmsg.UserRoleAssignmentFilter_AccountUuid{
+							AccountUuid: "invalid-&*&^%$#",
+						},
+					},
+				},
+			},
+			statusCode: http.StatusBadRequest,
+		},
+		"role filter without term": {
+			req: &v0.ListRoleAssignmentsFilteredRequest{
+				Filters: []*settingsmsg.UserRoleAssignmentFilter{
+					{
+						Type: settingsmsg.UserRoleAssignmentFilter_TYPE_ROLE,
+					},
+				},
+			},
+			statusCode: http.StatusBadRequest,
+		},
+		"role filter with invalid uuid": {
+			req: &v0.ListRoleAssignmentsFilteredRequest{
+				Filters: []*settingsmsg.UserRoleAssignmentFilter{
+					{
+						Type: settingsmsg.UserRoleAssignmentFilter_TYPE_ROLE,
+						Term: &settingsmsg.UserRoleAssignmentFilter_RoleId{
+							RoleId: "this is no uuid",
+						},
+					},
+				},
+			},
+			statusCode: http.StatusBadRequest,
+		},
+	}
+
+	for name, test := range tests {
+		t.Run(name, func(t *testing.T) {
+			res := v0.ListRoleAssignmentsResponse{}
+			err := svc.ListRoleAssignmentsFiltered(ctxWithUUID, test.req, &res)
+			merr, ok := merrors.As(err)
+			assert.True(t, ok)
+			assert.Equal(t, int32(test.statusCode), merr.Code)
+		})
+	}
+}

services/settings/pkg/service/v0/validator.go

@@ -1,6 +1,7 @@
 package svc
 
 import (
+	"errors"
 	"regexp"
 
 	validation "github.com/go-ozzo/ozzo-validation/v4"
@@ -116,6 +117,57 @@ func validateListRoleAssignments(req *settingssvc.ListRoleAssignmentsRequest) er
 	return validation.Validate(req.AccountUuid, requireAccountID...)
 }
 
+func validateListRoleAssignmentsFiltered(req *settingssvc.ListRoleAssignmentsFilteredRequest) error {
+	return validation.ValidateStruct(
+		req,
+		validation.Field(&req.Filters,
+			validation.Required,
+			validation.Length(1, 1),
+			validation.Each(validation.By(validateUserRoleAssignmentFilter)),
+		),
+	)
+}
+
+func validateUserRoleAssignmentFilter(values interface{}) error {
+	filter, ok := values.(settingsmsg.UserRoleAssignmentFilter)
+	if !ok {
+		return errors.New("expected UserRoleAssignmentFilter")
+	}
+	return validation.ValidateStruct(
+		&filter,
+		validation.Field(&filter.Type,
+			validation.Required,
+			validation.In(settingsmsg.UserRoleAssignmentFilter_TYPE_ACCOUNT, settingsmsg.UserRoleAssignmentFilter_TYPE_ROLE),
+		),
+		validation.Field(&filter.Term,
+			validation.When(
+				filter.Type == settingsmsg.UserRoleAssignmentFilter_TYPE_ACCOUNT,
+				validation.By(validateFilterAccountUUID),
+			),
+			validation.When(
+				filter.Type == settingsmsg.UserRoleAssignmentFilter_TYPE_ROLE,
+				validation.By(validateFilterRoleID),
+			),
+		),
+	)
+}
+
+func validateFilterRoleID(value interface{}) error {
+	roleTerm, ok := value.(*settingsmsg.UserRoleAssignmentFilter_RoleId)
+	if !ok {
+		return errors.New("expected UserRoleAssignmentFilter_RoleId")
+	}
+	return validation.Validate(&roleTerm.RoleId, is.UUID)
+}
+
+func validateFilterAccountUUID(value interface{}) error {
+	accountTerm, ok := value.(*settingsmsg.UserRoleAssignmentFilter_AccountUuid)
+	if !ok {
+		return errors.New("expected UserRoleAssignmentFilter_AccountUuid")
+	}
+	return validation.Validate(&accountTerm.AccountUuid, requireAccountID...)
+}
+
 func validateAssignRoleToUser(req *settingssvc.AssignRoleToUserRequest) error {
 	return validation.ValidateStruct(
 		req,