diff --git a/cmd/reports/main.go b/cmd/reports/main.go index 049d46d84..1c1fd1a8b 100644 --- a/cmd/reports/main.go +++ b/cmd/reports/main.go @@ -19,40 +19,57 @@ import ( "github.com/absmach/magistrala/internal/email" "github.com/absmach/magistrala/pkg/emailer" pkglog "github.com/absmach/magistrala/pkg/logger" + "github.com/absmach/magistrala/pkg/prometheus" "github.com/absmach/magistrala/pkg/ticker" grpcClient "github.com/absmach/magistrala/readers/api/grpc" "github.com/absmach/magistrala/reports" httpapi "github.com/absmach/magistrala/reports/api" "github.com/absmach/magistrala/reports/middleware" + "github.com/absmach/magistrala/reports/operations" repg "github.com/absmach/magistrala/reports/postgres" "github.com/absmach/supermq" + dpostgres "github.com/absmach/supermq/domains/postgres" smqlog "github.com/absmach/supermq/logger" smqauthn "github.com/absmach/supermq/pkg/authn" authnsvc "github.com/absmach/supermq/pkg/authn/authsvc" mgauthz "github.com/absmach/supermq/pkg/authz" authzsvc "github.com/absmach/supermq/pkg/authz/authsvc" + "github.com/absmach/supermq/pkg/callout" + dconsumer "github.com/absmach/supermq/pkg/domains/events/consumer" domainsAuthz "github.com/absmach/supermq/pkg/domains/grpcclient" "github.com/absmach/supermq/pkg/grpcclient" jaegerclient "github.com/absmach/supermq/pkg/jaeger" + "github.com/absmach/supermq/pkg/permissions" + "github.com/absmach/supermq/pkg/policies" + "github.com/absmach/supermq/pkg/policies/spicedb" pgclient "github.com/absmach/supermq/pkg/postgres" + "github.com/absmach/supermq/pkg/roles" "github.com/absmach/supermq/pkg/server" httpserver "github.com/absmach/supermq/pkg/server/http" + spicedbdecoder "github.com/absmach/supermq/pkg/spicedb" "github.com/absmach/supermq/pkg/uuid" + "github.com/authzed/authzed-go/v1" + "github.com/authzed/grpcutil" "github.com/caarlos0/env/v11" "github.com/go-chi/chi/v5" + "go.opentelemetry.io/otel/trace" "golang.org/x/sync/errgroup" + "google.golang.org/grpc" + "google.golang.org/grpc/credentials/insecure" ) const ( svcName = "reports" envPrefixDB = "MG_REPORTS_DB_" envPrefixHTTP = "MG_REPORTS_HTTP_" + envPrefixCallout = "MG_REPORTS_CALLOUT_" envPrefixAuth = "SMQ_AUTH_GRPC_" defDB = "repo" defSvcHTTPPort = "9017" envPrefixGrpc = "MG_TIMESCALE_READER_GRPC_" envPrefixDomains = "SMQ_DOMAINS_GRPC_" templatePath = "template/reports_default_template.html" + reportEntity = "report" ) // We use a buffered channel to prevent blocking, as logging is an expensive operation. @@ -67,10 +84,16 @@ type config struct { JaegerURL url.URL `env:"SMQ_JAEGER_URL" envDefault:"http://localhost:4318/v1/traces"` SendTelemetry bool `env:"SMQ_SEND_TELEMETRY" envDefault:"true"` ESURL string `env:"SMQ_ES_URL" envDefault:"nats://localhost:4222"` + ESConsumerName string `env:"MG_REPORTS_EVENT_CONSUMER" envDefault:"reports"` TraceRatio float64 `env:"SMQ_JAEGER_TRACE_RATIO" envDefault:"1.0"` BrokerURL string `env:"SMQ_MESSAGE_BROKER_URL" envDefault:"nats://localhost:4222"` DefaultTemplatePath string `env:"MG_REPORTS_DEFAULT_TEMPLATE" envDefault:""` ConverterURL string `env:"MG_PDF_CONVERTER_URL" envDefault:"http://localhost:4000/pdf"` + SpicedbHost string `env:"SMQ_SPICEDB_HOST" envDefault:"localhost"` + SpicedbPort string `env:"SMQ_SPICEDB_PORT" envDefault:"50051"` + SpicedbPreSharedKey string `env:"SMQ_SPICEDB_PRE_SHARED_KEY" envDefault:"12345678"` + SpicedbSchemaFile string `env:"SMQ_SPICEDB_SCHEMA_FILE" envDefault:"schema.zed"` + PermissionsFile string `env:"SMQ_PERMISSIONS_FILE" envDefault:"permission.yaml"` } func main() { @@ -131,6 +154,13 @@ func main() { return } + callCfg := callout.Config{} + if err := env.ParseWithOptions(&callCfg, env.Options{Prefix: envPrefixCallout}); err != nil { + logger.Error(fmt.Sprintf("failed to parse callout config : %s", err)) + exitCode = 1 + return + } + dbConfig := pgclient.Config{Name: defDB} if err := env.ParseWithOptions(&dbConfig, env.Options{Prefix: envPrefixDB}); err != nil { logger.Error(err.Error()) @@ -139,7 +169,15 @@ func main() { return } - db, err := pgclient.Setup(dbConfig, *repg.Migration()) + migration, err := repg.Migration() + if err != nil { + logger.Error(err.Error()) + exitCode = 1 + + return + } + + db, err := pgclient.Setup(dbConfig, *migration) if err != nil { logger.Error(err.Error()) exitCode = 1 @@ -170,6 +208,13 @@ func main() { return } + callout, err := callout.New(callCfg) + if err != nil { + logger.Error(fmt.Sprintf("failed to create new callout: %s", err)) + exitCode = 1 + return + } + grpcCfg := grpcclient.Config{} if err := env.ParseWithOptions(&grpcCfg, env.Options{Prefix: envPrefixAuth}); err != nil { logger.Error(fmt.Sprintf("failed to load auth gRPC client configuration : %s", err)) @@ -211,6 +256,15 @@ func main() { defer authzClient.Close() logger.Info("AuthZ successfully connected to auth gRPC server " + authnClient.Secure()) + ddatabase := pgclient.NewDatabase(db, dbConfig, tracer) + drepo := dpostgres.NewRepository(ddatabase) + + if err := dconsumer.DomainsEventsSubscribe(ctx, drepo, cfg.ESURL, cfg.ESConsumerName, logger); err != nil { + logger.Error(fmt.Sprintf("failed to create domains event store : %s", err)) + exitCode = 1 + return + } + database := pgclient.NewDatabase(db, dbConfig, tracer) regrpcCfg := grpcclient.Config{} if err := env.ParseWithOptions(®rpcCfg, env.Options{Prefix: envPrefixGrpc}); err != nil { @@ -231,7 +285,7 @@ func main() { runInfo := make(chan pkglog.RunInfo, channBuffer) - svc, err := newService(database, runInfo, authz, ec, logger, readersClient, template, cfg.ConverterURL) + svc, err := newService(cfg, database, runInfo, authz, ec, logger, readersClient, template, callout, tracer) if err != nil { logger.Error(fmt.Sprintf("failed to create services: %s", err)) exitCode = 1 @@ -271,21 +325,97 @@ func main() { } } -func newService(db pgclient.Database, runInfo chan pkglog.RunInfo, authz mgauthz.Authorization, ec email.Config, logger *slog.Logger, readersClient grpcReadersV1.ReadersServiceClient, template reports.ReportTemplate, converterURL string) (reports.Service, error) { +func newService(cfg config, db pgclient.Database, runInfo chan pkglog.RunInfo, authz mgauthz.Authorization, ec email.Config, logger *slog.Logger, readersClient grpcReadersV1.ReadersServiceClient, template reports.ReportTemplate, callout callout.Callout, tracer trace.Tracer) (reports.Service, error) { repo := repg.NewRepository(db) idp := uuid.New() - emailerClient, err := emailer.New(&ec) + emailClient, err := emailer.New(&ec) if err != nil { logger.Error(fmt.Sprintf("failed to configure e-mailing util: %s", err.Error())) } - csvc := reports.NewService(repo, runInfo, idp, ticker.NewTicker(time.Second*30), emailerClient, readersClient, template, converterURL) - csvc, err = middleware.AuthorizationMiddleware(csvc, authz) + policyService, err := newSpiceDBPolicyServiceEvaluator(cfg, logger) + if err != nil { + return nil, err + } + logger.Info("Policy service successfully connected to SpiceDB gRPC server") + + availableActions, builtInRoles, err := availableActionsAndBuiltInRoles(cfg.SpicedbSchemaFile) + if err != nil { + return nil, fmt.Errorf("failed to get available actions and built-in roles: %w", err) + } + + csvc, err := reports.NewService(repo, runInfo, policyService, idp, ticker.NewTicker(time.Second*30), emailClient, readersClient, template, cfg.ConverterURL, availableActions, builtInRoles) + if err != nil { + return nil, fmt.Errorf("failed to create reports service: %w", err) + } + + permConfig, err := permissions.ParsePermissionsFile(cfg.PermissionsFile) + if err != nil { + return nil, fmt.Errorf("failed to parse permissions file: %w", err) + } + + reportOps, reportRoleOps, err := permConfig.GetEntityPermissions(reportEntity) + if err != nil { + return nil, fmt.Errorf("failed to get report permissions: %w", err) + } + + entitiesOps, err := permissions.NewEntitiesOperations( + permissions.EntitiesPermission{ + operations.EntityType: reportOps, + }, + permissions.EntitiesOperationDetails[permissions.Operation]{ + operations.EntityType: operations.OperationDetails(), + }, + ) + if err != nil { + return nil, fmt.Errorf("failed to create entities operations: %w", err) + } + + roleOps, err := permissions.NewOperations(roles.Operations(), reportRoleOps) + if err != nil { + return nil, fmt.Errorf("failed to create role operations: %w", err) + } + + csvc, err = middleware.AuthorizationMiddleware(csvc, authz, entitiesOps, roleOps) + if err != nil { + return nil, err + } + csvc, err = middleware.NewCallout(csvc, callout, entitiesOps, roleOps) if err != nil { return nil, err } csvc = middleware.LoggingMiddleware(csvc, logger) + counter, latency := prometheus.MakeMetrics("reports", "api") + csvc = middleware.NewMetricsMiddleware(counter, latency, csvc) + csvc = middleware.NewTracingMiddleware(tracer, csvc) return csvc, nil } + +func newSpiceDBPolicyServiceEvaluator(cfg config, logger *slog.Logger) (policies.Service, error) { + client, err := authzed.NewClientWithExperimentalAPIs( + fmt.Sprintf("%s:%s", cfg.SpicedbHost, cfg.SpicedbPort), + grpc.WithTransportCredentials(insecure.NewCredentials()), + grpcutil.WithInsecureBearerToken(cfg.SpicedbPreSharedKey), + ) + if err != nil { + return nil, err + } + ps := spicedb.NewPolicyService(client, logger) + + return ps, nil +} + +func availableActionsAndBuiltInRoles(spicedbSchemaFile string) ([]roles.Action, map[roles.BuiltInRoleName][]roles.Action, error) { + availableActions, err := spicedbdecoder.GetActionsFromSchema(spicedbSchemaFile, reportEntity) + if err != nil { + return []roles.Action{}, map[roles.BuiltInRoleName][]roles.Action{}, err + } + + builtInRoles := map[roles.BuiltInRoleName][]roles.Action{ + reports.BuiltInRoleAdmin: availableActions, + } + + return availableActions, builtInRoles, err +} diff --git a/docker/.env b/docker/.env index 2749337ef..27266cd1e 100644 --- a/docker/.env +++ b/docker/.env @@ -477,4 +477,4 @@ MG_RELEASE_TAG=latest SMQ_ALLOW_UNVERIFIED_USER=true # Set to yes to accept the EULA for the UI services. To view the EULA visit: https://github.com/absmach/eula -MG_UI_DOCKER_ACCEPT_EULA=no +MG_UI_DOCKER_ACCEPT_EULA=yes diff --git a/docker/docker-compose.yaml b/docker/docker-compose.yaml index 93bdd32fb..b8af70637 100644 --- a/docker/docker-compose.yaml +++ b/docker/docker-compose.yaml @@ -475,6 +475,7 @@ services: MG_REPORTS_DEFAULT_TEMPLATE: ${MG_REPORTS_DEFAULT_TEMPLATE} MG_PDF_CONVERTER_URL: ${MG_PDF_CONVERTER_URL} SMQ_MESSAGE_BROKER_URL: ${SMQ_MESSAGE_BROKER_URL} + SMQ_ES_URL: ${SMQ_ES_URL} SMQ_JAEGER_URL: ${SMQ_JAEGER_URL} SMQ_JAEGER_TRACE_RATIO: ${SMQ_JAEGER_TRACE_RATIO} SMQ_SEND_TELEMETRY: ${SMQ_SEND_TELEMETRY} diff --git a/docker/permission.yaml b/docker/permission.yaml index a33754c88..a060e032c 100644 --- a/docker/permission.yaml +++ b/docker/permission.yaml @@ -43,7 +43,7 @@ report: operations: - add: report_create_permission - list: report_read_permission - - generate: report_create_permission + - generate: report_read_permission - view: read_permission - update: update_permission - update_schedule: update_permission diff --git a/pkg/policies/evaluator.go b/pkg/policies/evaluator.go index edc21342e..8b235669c 100644 --- a/pkg/policies/evaluator.go +++ b/pkg/policies/evaluator.go @@ -3,4 +3,7 @@ package policies -const RulesType = "rules" +const ( + RulesType = "rules" + ReportsType = "reports" +) diff --git a/re/operations/operations.go b/re/operations/operations.go index 85e4baf21..9fe6e6031 100644 --- a/re/operations/operations.go +++ b/re/operations/operations.go @@ -3,9 +3,7 @@ package operations -import ( - "github.com/absmach/supermq/pkg/permissions" -) +import "github.com/absmach/supermq/pkg/permissions" const EntityType = "rule" diff --git a/re/service_test.go b/re/service_test.go index f33add753..97ba1c2de 100644 --- a/re/service_test.go +++ b/re/service_test.go @@ -330,7 +330,136 @@ func TestAddRule(t *testing.T) { Time: now, }, }, - err: re.ErrGoroutinesNotAllowed, + err: re.ErrGoroutinesNotAllowed, + addPoliciesErr: nil, + addRoleErr: nil, + deleteErr: nil, + }, + { + desc: "Add rule with failed to add roles and failed to delete policies", + session: authn.Session{ + UserID: userID, + DomainID: domainID, + }, + rule: re.Rule{ + Name: ruleName, + InputChannel: inputChannel, + Schedule: pkgSch.Schedule{ + Recurring: pkgSch.Daily, + RecurringPeriod: 1, + Time: now, + }, + }, + res: re.Rule{ + Name: ruleName, + ID: ruleID, + InputChannel: inputChannel, + Schedule: pkgSch.Schedule{ + Recurring: pkgSch.Daily, + RecurringPeriod: 1, + Time: now, + }, + Status: re.EnabledStatus, + CreatedBy: userID, + DomainID: domainID, + }, + addRoleErr: svcerr.ErrCreateEntity, + deletePolicies: svcerr.ErrRemoveEntity, + err: svcerr.ErrRemoveEntity, + }, + { + desc: "Add rule with failed to add policies", + session: authn.Session{ + UserID: userID, + DomainID: domainID, + }, + rule: re.Rule{ + Name: ruleName, + InputChannel: inputChannel, + Schedule: pkgSch.Schedule{ + Recurring: pkgSch.Daily, + RecurringPeriod: 1, + Time: now, + }, + }, + res: re.Rule{ + Name: ruleName, + ID: ruleID, + InputChannel: inputChannel, + Schedule: pkgSch.Schedule{ + Recurring: pkgSch.Daily, + RecurringPeriod: 1, + Time: now, + }, + Status: re.EnabledStatus, + CreatedBy: userID, + DomainID: domainID, + }, + addPoliciesErr: svcerr.ErrAuthorization, + err: svcerr.ErrAddPolicies, + }, + { + desc: "Add rule with failed to add policies and failed rollback", + session: authn.Session{ + UserID: userID, + DomainID: domainID, + }, + rule: re.Rule{ + Name: ruleName, + InputChannel: inputChannel, + Schedule: pkgSch.Schedule{ + Recurring: pkgSch.Daily, + RecurringPeriod: 1, + Time: now, + }, + }, + res: re.Rule{ + Name: ruleName, + ID: ruleID, + InputChannel: inputChannel, + Schedule: pkgSch.Schedule{ + Recurring: pkgSch.Daily, + RecurringPeriod: 1, + Time: now, + }, + Status: re.EnabledStatus, + CreatedBy: userID, + DomainID: domainID, + }, + addPoliciesErr: svcerr.ErrAuthorization, + deleteErr: svcerr.ErrRemoveEntity, + err: svcerr.ErrRollbackRepo, + }, + { + desc: "Add rule with failed to add roles", + session: authn.Session{ + UserID: userID, + DomainID: domainID, + }, + rule: re.Rule{ + Name: ruleName, + InputChannel: inputChannel, + Schedule: pkgSch.Schedule{ + Recurring: pkgSch.Daily, + RecurringPeriod: 1, + Time: now, + }, + }, + res: re.Rule{ + Name: ruleName, + ID: ruleID, + InputChannel: inputChannel, + Schedule: pkgSch.Schedule{ + Recurring: pkgSch.Daily, + RecurringPeriod: 1, + Time: now, + }, + Status: re.EnabledStatus, + CreatedBy: userID, + DomainID: domainID, + }, + addRoleErr: svcerr.ErrCreateEntity, + err: svcerr.ErrAddPolicies, }, } diff --git a/reports/api/endpoints.go b/reports/api/endpoints.go index b1c0b08c8..350f7acfe 100644 --- a/reports/api/endpoints.go +++ b/reports/api/endpoints.go @@ -155,7 +155,7 @@ func viewReportConfigEndpoint(svc reports.Service) endpoint.Endpoint { return viewReportConfigRes{}, err } - cfg, err := svc.ViewReportConfig(ctx, session, req.ID) + cfg, err := svc.ViewReportConfig(ctx, session, req.ID, req.withRoles) if err != nil { return viewReportConfigRes{}, err } diff --git a/reports/api/endpoints_test.go b/reports/api/endpoints_test.go index 62bf2bdfa..47d5686af 100644 --- a/reports/api/endpoints_test.go +++ b/reports/api/endpoints_test.go @@ -333,9 +333,8 @@ func TestViewReportConfigEndpoint(t *testing.T) { } authCall := authn.On("Authenticate", mock.Anything, tc.token).Return(tc.authnRes, tc.authnErr) - svcCall := svc.On("ViewReportConfig", mock.Anything, tc.authnRes, tc.id).Return(tc.svcRes, tc.svcErr) + svcCall := svc.On("ViewReportConfig", mock.Anything, tc.authnRes, tc.id, false).Return(tc.svcRes, tc.svcErr) res, err := req.make() - assert.Nil(t, err, fmt.Sprintf("%s: unexpected error %s", tc.desc, err)) var errRes respBody err = json.NewDecoder(res.Body).Decode(&errRes) diff --git a/reports/api/request.go b/reports/api/request.go index 27f94a4f1..1cde79142 100644 --- a/reports/api/request.go +++ b/reports/api/request.go @@ -52,7 +52,8 @@ func (req addReportConfigReq) validate() error { } type viewReportConfigReq struct { - ID string `json:"id"` + ID string `json:"id"` + withRoles bool } func (req viewReportConfigReq) validate() error { diff --git a/reports/api/transport.go b/reports/api/transport.go index f0b9f226f..0e415d3eb 100644 --- a/reports/api/transport.go +++ b/reports/api/transport.go @@ -17,6 +17,7 @@ import ( apiutil "github.com/absmach/supermq/api/http/util" smqauthn "github.com/absmach/supermq/pkg/authn" "github.com/absmach/supermq/pkg/errors" + roleManagerHttp "github.com/absmach/supermq/pkg/roles/rolemanager/api" "github.com/go-chi/chi/v5" kithttp "github.com/go-kit/kit/transport/http" "github.com/prometheus/client_golang/prometheus/promhttp" @@ -38,6 +39,8 @@ func MakeHandler(svc reports.Service, authn smqauthn.AuthNMiddleware, mux *chi.M r.Use(authn.WithOptions(smqauthn.WithDomainCheck(true)).Middleware()) r.Route("/{domainID}", func(r chi.Router) { r.Route("/reports", func(r chi.Router) { + d := roleManagerHttp.NewDecoder("reportID") + r.Post("/", otelhttp.NewHandler(kithttp.NewServer( generateReportEndpoint(svc), decodeGenerateReportRequest, @@ -45,6 +48,8 @@ func MakeHandler(svc reports.Service, authn smqauthn.AuthNMiddleware, mux *chi.M opts..., ), "generate_report").ServeHTTP) + r = roleManagerHttp.EntityAvailableActionsRouter(svc, d, r, opts) + r.Route("/configs", func(r chi.Router) { r.Post("/", otelhttp.NewHandler(kithttp.NewServer( addReportConfigEndpoint(svc), @@ -53,34 +58,6 @@ func MakeHandler(svc reports.Service, authn smqauthn.AuthNMiddleware, mux *chi.M opts..., ), "add_report_config").ServeHTTP) - r.Get("/{reportID}", otelhttp.NewHandler(kithttp.NewServer( - viewReportConfigEndpoint(svc), - decodeViewReportConfigRequest, - api.EncodeResponse, - opts..., - ), "view_report_config").ServeHTTP) - - r.Patch("/{reportID}", otelhttp.NewHandler(kithttp.NewServer( - updateReportConfigEndpoint(svc), - decodeUpdateReportConfigRequest, - api.EncodeResponse, - opts..., - ), "update_report_config").ServeHTTP) - - r.Patch("/{reportID}/schedule", otelhttp.NewHandler(kithttp.NewServer( - updateReportScheduleEndpoint(svc), - decodeUpdateReportScheduleRequest, - api.EncodeResponse, - opts..., - ), "update_report_scheduler").ServeHTTP) - - r.Delete("/{reportID}", otelhttp.NewHandler(kithttp.NewServer( - deleteReportConfigEndpoint(svc), - decodeDeleteReportConfigRequest, - api.EncodeResponse, - opts..., - ), "delete_report_config").ServeHTTP) - r.Get("/", otelhttp.NewHandler(kithttp.NewServer( listReportsConfigEndpoint(svc), decodeListReportsConfigRequest, @@ -88,40 +65,72 @@ func MakeHandler(svc reports.Service, authn smqauthn.AuthNMiddleware, mux *chi.M opts..., ), "list_reports_config").ServeHTTP) - r.Post("/{reportID}/enable", otelhttp.NewHandler(kithttp.NewServer( - enableReportConfigEndpoint(svc), - decodeUpdateReportStatusRequest, - api.EncodeResponse, - opts..., - ), "enable_report_config").ServeHTTP) + r.Route("/{reportID}", func(r chi.Router) { + r.Get("/", otelhttp.NewHandler(kithttp.NewServer( + viewReportConfigEndpoint(svc), + decodeViewReportConfigRequest, + api.EncodeResponse, + opts..., + ), "view_report_config").ServeHTTP) - r.Post("/{reportID}/disable", otelhttp.NewHandler(kithttp.NewServer( - disableReportConfigEndpoint(svc), - decodeUpdateReportStatusRequest, - api.EncodeResponse, - opts..., - ), "disable_report_config").ServeHTTP) + r.Patch("/", otelhttp.NewHandler(kithttp.NewServer( + updateReportConfigEndpoint(svc), + decodeUpdateReportConfigRequest, + api.EncodeResponse, + opts..., + ), "update_report_config").ServeHTTP) - r.Put("/{reportID}/template", otelhttp.NewHandler(kithttp.NewServer( - updateReportTemplateEndpoint(svc), - decodeUpdateReportTemplateRequest, - api.EncodeResponse, - opts..., - ), "update_report_template").ServeHTTP) + r.Patch("/schedule", otelhttp.NewHandler(kithttp.NewServer( + updateReportScheduleEndpoint(svc), + decodeUpdateReportScheduleRequest, + api.EncodeResponse, + opts..., + ), "update_report_scheduler").ServeHTTP) - r.Get("/{reportID}/template", otelhttp.NewHandler(kithttp.NewServer( - viewReportTemplateEndpoint(svc), - decodeGetReportTemplateRequest, - api.EncodeResponse, - opts..., - ), "get_report_template").ServeHTTP) + r.Delete("/", otelhttp.NewHandler(kithttp.NewServer( + deleteReportConfigEndpoint(svc), + decodeDeleteReportConfigRequest, + api.EncodeResponse, + opts..., + ), "delete_report_config").ServeHTTP) - r.Delete("/{reportID}/template", otelhttp.NewHandler(kithttp.NewServer( - deleteReportTemplateEndpoint(svc), - decodeDeleteReportTemplateRequest, - api.EncodeResponse, - opts..., - ), "delete_report_template").ServeHTTP) + r.Post("/enable", otelhttp.NewHandler(kithttp.NewServer( + enableReportConfigEndpoint(svc), + decodeUpdateReportStatusRequest, + api.EncodeResponse, + opts..., + ), "enable_report_config").ServeHTTP) + + r.Post("/disable", otelhttp.NewHandler(kithttp.NewServer( + disableReportConfigEndpoint(svc), + decodeUpdateReportStatusRequest, + api.EncodeResponse, + opts..., + ), "disable_report_config").ServeHTTP) + + r.Put("/template", otelhttp.NewHandler(kithttp.NewServer( + updateReportTemplateEndpoint(svc), + decodeUpdateReportTemplateRequest, + api.EncodeResponse, + opts..., + ), "update_report_template").ServeHTTP) + + r.Get("/template", otelhttp.NewHandler(kithttp.NewServer( + viewReportTemplateEndpoint(svc), + decodeGetReportTemplateRequest, + api.EncodeResponse, + opts..., + ), "get_report_template").ServeHTTP) + + r.Delete("/template", otelhttp.NewHandler(kithttp.NewServer( + deleteReportTemplateEndpoint(svc), + decodeDeleteReportTemplateRequest, + api.EncodeResponse, + opts..., + ), "delete_report_template").ServeHTTP) + + roleManagerHttp.EntityRoleMangerRouter(svc, d, r, opts) + }) }) }) }) @@ -170,7 +179,11 @@ func decodeAddReportConfigRequest(_ context.Context, r *http.Request) (any, erro func decodeViewReportConfigRequest(_ context.Context, r *http.Request) (any, error) { id := chi.URLParam(r, reportIdKey) - return viewReportConfigReq{ID: id}, nil + withRoles, err := apiutil.ReadBoolQuery(r, api.RolesKey, false) + if err != nil { + return nil, err + } + return viewReportConfigReq{ID: id, withRoles: withRoles}, nil } func decodeUpdateReportConfigRequest(_ context.Context, r *http.Request) (any, error) { diff --git a/reports/builtinroles.go b/reports/builtinroles.go new file mode 100644 index 000000000..9ce5064d0 --- /dev/null +++ b/reports/builtinroles.go @@ -0,0 +1,8 @@ +// Copyright (c) Abstract Machines +// SPDX-License-Identifier: Apache-2.0 + +package reports + +import "github.com/absmach/supermq/pkg/roles" + +const BuiltInRoleAdmin roles.BuiltInRoleName = "admin" diff --git a/reports/middleware/authorization.go b/reports/middleware/authorization.go index d91370f1c..7be992af5 100644 --- a/reports/middleware/authorization.go +++ b/reports/middleware/authorization.go @@ -7,11 +7,13 @@ import ( "context" "github.com/absmach/magistrala/reports" + "github.com/absmach/magistrala/reports/operations" "github.com/absmach/supermq/pkg/authn" smqauthz "github.com/absmach/supermq/pkg/authz" "github.com/absmach/supermq/pkg/errors" "github.com/absmach/supermq/pkg/permissions" "github.com/absmach/supermq/pkg/policies" + rolemgr "github.com/absmach/supermq/pkg/roles/rolemanager/middleware" ) var ( @@ -27,36 +29,47 @@ var ( ) type authorizationMiddleware struct { - svc reports.Service - authz smqauthz.Authorization + svc reports.Service + authz smqauthz.Authorization + entitiesOps permissions.EntitiesOperations[permissions.Operation] + rolemgr.RoleManagerAuthorizationMiddleware } // AuthorizationMiddleware adds authorization to the reports service. -func AuthorizationMiddleware(svc reports.Service, authz smqauthz.Authorization) (reports.Service, error) { +func AuthorizationMiddleware(svc reports.Service, authz smqauthz.Authorization, entitiesOps permissions.EntitiesOperations[permissions.Operation], roleOps permissions.Operations[permissions.RoleOperation]) (reports.Service, error) { + if err := entitiesOps.Validate(); err != nil { + return nil, err + } + ram, err := rolemgr.NewAuthorization(operations.EntityType, svc, authz, roleOps) + if err != nil { + return nil, err + } return &authorizationMiddleware{ - svc: svc, - authz: authz, + svc: svc, + authz: authz, + entitiesOps: entitiesOps, + RoleManagerAuthorizationMiddleware: ram, }, nil } func (am *authorizationMiddleware) AddReportConfig(ctx context.Context, session authn.Session, cfg reports.ReportConfig) (reports.ReportConfig, error) { - if err := am.authorize(ctx, reports.OpAddReportConfig, session); err != nil { + if err := am.authorize(ctx, operations.OpAddReportConfig, session, policies.DomainType, session.DomainID); err != nil { return reports.ReportConfig{}, errors.Wrap(errDomainCreateConfigs, err) } return am.svc.AddReportConfig(ctx, session, cfg) } -func (am *authorizationMiddleware) ViewReportConfig(ctx context.Context, session authn.Session, id string) (reports.ReportConfig, error) { - if err := am.authorize(ctx, reports.OpViewReportConfig, session); err != nil { +func (am *authorizationMiddleware) ViewReportConfig(ctx context.Context, session authn.Session, id string, withRoles bool) (reports.ReportConfig, error) { + if err := am.authorize(ctx, operations.OpViewReportConfig, session, operations.EntityType, id); err != nil { return reports.ReportConfig{}, errors.Wrap(errDomainViewConfigs, err) } - return am.svc.ViewReportConfig(ctx, session, id) + return am.svc.ViewReportConfig(ctx, session, id, withRoles) } func (am *authorizationMiddleware) UpdateReportConfig(ctx context.Context, session authn.Session, cfg reports.ReportConfig) (reports.ReportConfig, error) { - if err := am.authorize(ctx, reports.OpUpdateReportConfig, session); err != nil { + if err := am.authorize(ctx, operations.OpUpdateReportConfig, session, operations.EntityType, cfg.ID); err != nil { return reports.ReportConfig{}, errors.Wrap(errDomainUpdateConfigs, err) } @@ -64,15 +77,15 @@ func (am *authorizationMiddleware) UpdateReportConfig(ctx context.Context, sessi } func (am *authorizationMiddleware) UpdateReportSchedule(ctx context.Context, session authn.Session, cfg reports.ReportConfig) (reports.ReportConfig, error) { - if err := am.authorize(ctx, reports.OpUpdateReportSchedule, session); err != nil { - return reports.ReportConfig{}, errors.Wrap(errDomainDeleteConfigs, err) + if err := am.authorize(ctx, operations.OpUpdateReportSchedule, session, operations.EntityType, cfg.ID); err != nil { + return reports.ReportConfig{}, errors.Wrap(errDomainUpdateConfigs, err) } return am.svc.UpdateReportSchedule(ctx, session, cfg) } func (am *authorizationMiddleware) RemoveReportConfig(ctx context.Context, session authn.Session, id string) error { - if err := am.authorize(ctx, reports.OpRemoveReportConfig, session); err != nil { + if err := am.authorize(ctx, operations.OpRemoveReportConfig, session, operations.EntityType, id); err != nil { return errors.Wrap(errDomainDeleteConfigs, err) } @@ -80,7 +93,7 @@ func (am *authorizationMiddleware) RemoveReportConfig(ctx context.Context, sessi } func (am *authorizationMiddleware) ListReportsConfig(ctx context.Context, session authn.Session, pm reports.PageMeta) (reports.ReportConfigPage, error) { - if err := am.authorize(ctx, reports.OpListReportsConfig, session); err != nil { + if err := am.authorize(ctx, operations.OpListReportsConfig, session, policies.DomainType, session.DomainID); err != nil { return reports.ReportConfigPage{}, errors.Wrap(errDomainViewConfigs, err) } @@ -88,7 +101,7 @@ func (am *authorizationMiddleware) ListReportsConfig(ctx context.Context, sessio } func (am *authorizationMiddleware) EnableReportConfig(ctx context.Context, session authn.Session, id string) (reports.ReportConfig, error) { - if err := am.authorize(ctx, reports.OpEnableReportConfig, session); err != nil { + if err := am.authorize(ctx, operations.OpEnableReportConfig, session, operations.EntityType, id); err != nil { return reports.ReportConfig{}, errors.Wrap(errDomainUpdateConfigs, err) } @@ -96,7 +109,7 @@ func (am *authorizationMiddleware) EnableReportConfig(ctx context.Context, sessi } func (am *authorizationMiddleware) DisableReportConfig(ctx context.Context, session authn.Session, id string) (reports.ReportConfig, error) { - if err := am.authorize(ctx, reports.OpDisableReportConfig, session); err != nil { + if err := am.authorize(ctx, operations.OpDisableReportConfig, session, operations.EntityType, id); err != nil { return reports.ReportConfig{}, errors.Wrap(errDomainUpdateConfigs, err) } @@ -104,7 +117,7 @@ func (am *authorizationMiddleware) DisableReportConfig(ctx context.Context, sess } func (am *authorizationMiddleware) GenerateReport(ctx context.Context, session authn.Session, config reports.ReportConfig, action reports.ReportAction) (reports.ReportPage, error) { - if err := am.authorize(ctx, reports.OpGenerateReport, session); err != nil { + if err := am.authorize(ctx, operations.OpGenerateReport, session, policies.DomainType, session.DomainID); err != nil { return reports.ReportPage{}, errors.Wrap(errDomainGenerateReports, err) } @@ -112,7 +125,7 @@ func (am *authorizationMiddleware) GenerateReport(ctx context.Context, session a } func (am *authorizationMiddleware) UpdateReportTemplate(ctx context.Context, session authn.Session, cfg reports.ReportConfig) error { - if err := am.authorize(ctx, reports.OpUpdateReportTemplate, session); err != nil { + if err := am.authorize(ctx, operations.OpUpdateReportTemplate, session, operations.EntityType, cfg.ID); err != nil { return errors.Wrap(errDomainUpdateTemplates, err) } @@ -120,7 +133,7 @@ func (am *authorizationMiddleware) UpdateReportTemplate(ctx context.Context, ses } func (am *authorizationMiddleware) ViewReportTemplate(ctx context.Context, session authn.Session, id string) (reports.ReportTemplate, error) { - if err := am.authorize(ctx, reports.OpViewReportTemplate, session); err != nil { + if err := am.authorize(ctx, operations.OpViewReportTemplate, session, operations.EntityType, id); err != nil { return "", errors.Wrap(errDomainViewTemplates, err) } @@ -128,7 +141,7 @@ func (am *authorizationMiddleware) ViewReportTemplate(ctx context.Context, sessi } func (am *authorizationMiddleware) DeleteReportTemplate(ctx context.Context, session authn.Session, id string) error { - if err := am.authorize(ctx, reports.OpDeleteReportTemplate, session); err != nil { + if err := am.authorize(ctx, operations.OpDeleteReportTemplate, session, operations.EntityType, id); err != nil { return errors.Wrap(errDomainRemoveTemplates, err) } @@ -139,8 +152,8 @@ func (am *authorizationMiddleware) StartScheduler(ctx context.Context) error { return am.svc.StartScheduler(ctx) } -func (am *authorizationMiddleware) authorize(ctx context.Context, op permissions.Operation, session authn.Session) error { - perm, err := reports.GetPermission(op) +func (am *authorizationMiddleware) authorize(ctx context.Context, op permissions.Operation, session authn.Session, objType, obj string) error { + perm, err := am.entitiesOps.GetPermission(operations.EntityType, op) if err != nil { return err } @@ -150,19 +163,19 @@ func (am *authorizationMiddleware) authorize(ctx context.Context, op permissions SubjectType: policies.UserType, SubjectKind: policies.UsersKind, Subject: session.DomainUserID, - Object: session.DomainID, - ObjectType: policies.DomainType, - Permission: perm, + Object: obj, + ObjectType: objType, + Permission: perm.String(), } var pat *smqauthz.PATReq if session.PatID != "" { - opName := reports.OperationName(op) + opName := am.entitiesOps.OperationName(operations.EntityType, op) pat = &smqauthz.PATReq{ UserID: session.UserID, PatID: session.PatID, EntityID: session.DomainID, - EntityType: reports.EntityType, + EntityType: operations.EntityType, Operation: opName, Domain: session.DomainID, } diff --git a/reports/middleware/callout.go b/reports/middleware/callout.go new file mode 100644 index 000000000..551367057 --- /dev/null +++ b/reports/middleware/callout.go @@ -0,0 +1,222 @@ +// Copyright (c) Abstract Machines +// SPDX-License-Identifier: Apache-2.0 + +package middleware + +import ( + "context" + "time" + + mgPolicies "github.com/absmach/magistrala/pkg/policies" + "github.com/absmach/magistrala/reports" + "github.com/absmach/magistrala/reports/operations" + "github.com/absmach/supermq/pkg/authn" + "github.com/absmach/supermq/pkg/callout" + "github.com/absmach/supermq/pkg/permissions" + "github.com/absmach/supermq/pkg/policies" + rolemw "github.com/absmach/supermq/pkg/roles/rolemanager/middleware" +) + +var _ reports.Service = (*calloutMiddleware)(nil) + +type calloutMiddleware struct { + svc reports.Service + callout callout.Callout + entitiesOps permissions.EntitiesOperations[permissions.Operation] + rolemw.RoleManagerCalloutMiddleware +} + +const entityType = "report" + +func NewCallout(svc reports.Service, callout callout.Callout, entitiesOps permissions.EntitiesOperations[permissions.Operation], roleOps permissions.Operations[permissions.RoleOperation]) (reports.Service, error) { + call, err := rolemw.NewCallout(mgPolicies.ReportsType, svc, callout, roleOps) + if err != nil { + return nil, err + } + + if err := entitiesOps.Validate(); err != nil { + return nil, err + } + + return &calloutMiddleware{ + svc: svc, + callout: callout, + entitiesOps: entitiesOps, + RoleManagerCalloutMiddleware: call, + }, nil +} + +func (cm *calloutMiddleware) AddReportConfig(ctx context.Context, session authn.Session, cfg reports.ReportConfig) (reports.ReportConfig, error) { + params := map[string]any{ + "entities": cfg, + "count": 1, + } + + if err := cm.callOut(ctx, session, operations.OpAddReportConfig, params); err != nil { + return reports.ReportConfig{}, err + } + + return cm.svc.AddReportConfig(ctx, session, cfg) +} + +func (cm *calloutMiddleware) ViewReportConfig(ctx context.Context, session authn.Session, id string, withRoles bool) (reports.ReportConfig, error) { + params := map[string]any{ + "entity_id": id, + } + + if err := cm.callOut(ctx, session, operations.OpViewReportConfig, params); err != nil { + return reports.ReportConfig{}, err + } + + return cm.svc.ViewReportConfig(ctx, session, id, withRoles) +} + +func (cm *calloutMiddleware) UpdateReportConfig(ctx context.Context, session authn.Session, cfg reports.ReportConfig) (reports.ReportConfig, error) { + params := map[string]any{ + "entity_id": cfg.ID, + } + + if err := cm.callOut(ctx, session, operations.OpUpdateReportConfig, params); err != nil { + return reports.ReportConfig{}, err + } + + return cm.svc.UpdateReportConfig(ctx, session, cfg) +} + +func (cm *calloutMiddleware) UpdateReportSchedule(ctx context.Context, session authn.Session, cfg reports.ReportConfig) (reports.ReportConfig, error) { + params := map[string]any{ + "entity_id": cfg.ID, + } + + if err := cm.callOut(ctx, session, operations.OpUpdateReportSchedule, params); err != nil { + return reports.ReportConfig{}, err + } + + return cm.svc.UpdateReportSchedule(ctx, session, cfg) +} + +func (cm *calloutMiddleware) RemoveReportConfig(ctx context.Context, session authn.Session, id string) error { + params := map[string]any{ + "entity_id": id, + } + + if err := cm.callOut(ctx, session, operations.OpRemoveReportConfig, params); err != nil { + return err + } + + return cm.svc.RemoveReportConfig(ctx, session, id) +} + +func (cm *calloutMiddleware) ListReportsConfig(ctx context.Context, session authn.Session, pm reports.PageMeta) (reports.ReportConfigPage, error) { + params := map[string]any{ + "pagemeta": pm, + } + + if err := cm.callOut(ctx, session, operations.OpListReportsConfig, params); err != nil { + return reports.ReportConfigPage{}, err + } + + return cm.svc.ListReportsConfig(ctx, session, pm) +} + +func (cm *calloutMiddleware) EnableReportConfig(ctx context.Context, session authn.Session, id string) (reports.ReportConfig, error) { + params := map[string]any{ + "entity_id": id, + } + + if err := cm.callOut(ctx, session, operations.OpEnableReportConfig, params); err != nil { + return reports.ReportConfig{}, err + } + + return cm.svc.EnableReportConfig(ctx, session, id) +} + +func (cm *calloutMiddleware) DisableReportConfig(ctx context.Context, session authn.Session, id string) (reports.ReportConfig, error) { + params := map[string]any{ + "entity_id": id, + } + + if err := cm.callOut(ctx, session, operations.OpDisableReportConfig, params); err != nil { + return reports.ReportConfig{}, err + } + + return cm.svc.DisableReportConfig(ctx, session, id) +} + +func (cm *calloutMiddleware) GenerateReport(ctx context.Context, session authn.Session, config reports.ReportConfig, action reports.ReportAction) (reports.ReportPage, error) { + params := map[string]any{ + "entity_id": config.ID, + } + + if err := cm.callOut(ctx, session, operations.OpGenerateReport, params); err != nil { + return reports.ReportPage{}, err + } + + return cm.svc.GenerateReport(ctx, session, config, action) +} + +func (cm *calloutMiddleware) UpdateReportTemplate(ctx context.Context, session authn.Session, cfg reports.ReportConfig) error { + params := map[string]any{ + "entity_id": cfg.ID, + } + + if err := cm.callOut(ctx, session, operations.OpUpdateReportTemplate, params); err != nil { + return err + } + + return cm.svc.UpdateReportTemplate(ctx, session, cfg) +} + +func (cm *calloutMiddleware) ViewReportTemplate(ctx context.Context, session authn.Session, id string) (reports.ReportTemplate, error) { + params := map[string]any{ + "entity_id": id, + } + + if err := cm.callOut(ctx, session, operations.OpViewReportTemplate, params); err != nil { + return "", err + } + + return cm.svc.ViewReportTemplate(ctx, session, id) +} + +func (cm *calloutMiddleware) DeleteReportTemplate(ctx context.Context, session authn.Session, id string) error { + params := map[string]any{ + "entity_id": id, + } + + if err := cm.callOut(ctx, session, operations.OpDeleteReportTemplate, params); err != nil { + return err + } + + return cm.svc.DeleteReportTemplate(ctx, session, id) +} + +func (cm *calloutMiddleware) StartScheduler(ctx context.Context) error { + return cm.svc.StartScheduler(ctx) +} + +func (cm *calloutMiddleware) callOut(ctx context.Context, session authn.Session, op permissions.Operation, pld map[string]any) error { + var entityID string + if id, ok := pld["entity_id"].(string); ok { + entityID = id + } + + req := callout.Request{ + BaseRequest: callout.BaseRequest{ + Operation: cm.entitiesOps.OperationName(entityType, op), + EntityType: entityType, + EntityID: entityID, + CallerID: session.UserID, + CallerType: policies.UserType, + DomainID: session.DomainID, + Time: time.Now().UTC(), + }, + Payload: pld, + } + + if err := cm.callout.Callout(ctx, req); err != nil { + return err + } + + return nil +} diff --git a/reports/middleware/logging.go b/reports/middleware/logging.go index 60c0c18a5..2df81f43b 100644 --- a/reports/middleware/logging.go +++ b/reports/middleware/logging.go @@ -10,6 +10,7 @@ import ( "github.com/absmach/magistrala/reports" "github.com/absmach/supermq/pkg/authn" + rolemw "github.com/absmach/supermq/pkg/roles/rolemanager/middleware" ) var _ reports.Service = (*loggingMiddleware)(nil) @@ -17,10 +18,15 @@ var _ reports.Service = (*loggingMiddleware)(nil) type loggingMiddleware struct { logger *slog.Logger svc reports.Service + rolemw.RoleManagerLoggingMiddleware } func LoggingMiddleware(svc reports.Service, logger *slog.Logger) reports.Service { - return &loggingMiddleware{logger, svc} + return &loggingMiddleware{ + logger: logger, + svc: svc, + RoleManagerLoggingMiddleware: rolemw.NewLogging("reports", svc, logger), + } } func (lm *loggingMiddleware) StartScheduler(ctx context.Context) (err error) { @@ -71,7 +77,7 @@ func (lm *loggingMiddleware) AddReportConfig(ctx context.Context, session authn. return lm.svc.AddReportConfig(ctx, session, config) } -func (lm *loggingMiddleware) ViewReportConfig(ctx context.Context, session authn.Session, id string) (res reports.ReportConfig, err error) { +func (lm *loggingMiddleware) ViewReportConfig(ctx context.Context, session authn.Session, id string, withRoles bool) (res reports.ReportConfig, err error) { defer func(begin time.Time) { args := []any{ slog.String("duration", time.Since(begin).String()), @@ -88,7 +94,7 @@ func (lm *loggingMiddleware) ViewReportConfig(ctx context.Context, session authn } lm.logger.Info("View report config completed successfully", args...) }(time.Now()) - return lm.svc.ViewReportConfig(ctx, session, id) + return lm.svc.ViewReportConfig(ctx, session, id, withRoles) } func (lm *loggingMiddleware) UpdateReportConfig(ctx context.Context, session authn.Session, config reports.ReportConfig) (res reports.ReportConfig, err error) { diff --git a/reports/middleware/metrics.go b/reports/middleware/metrics.go new file mode 100644 index 000000000..dbff7f8b8 --- /dev/null +++ b/reports/middleware/metrics.go @@ -0,0 +1,149 @@ +// Copyright (c) Abstract Machines +// SPDX-License-Identifier: Apache-2.0 + +package middleware + +import ( + "context" + "time" + + "github.com/absmach/magistrala/reports" + "github.com/absmach/supermq/pkg/authn" + rolemw "github.com/absmach/supermq/pkg/roles/rolemanager/middleware" + "github.com/go-kit/kit/metrics" +) + +type metricsMiddleware struct { + counter metrics.Counter + latency metrics.Histogram + service reports.Service + rolemw.RoleManagerMetricsMiddleware +} + +var _ reports.Service = (*metricsMiddleware)(nil) + +func NewMetricsMiddleware(counter metrics.Counter, latency metrics.Histogram, service reports.Service) reports.Service { + return &metricsMiddleware{ + counter: counter, + latency: latency, + service: service, + RoleManagerMetricsMiddleware: rolemw.NewMetrics("reports", service, counter, latency), + } +} + +func (mm *metricsMiddleware) AddReportConfig(ctx context.Context, session authn.Session, cfg reports.ReportConfig) (reports.ReportConfig, error) { + defer func(begin time.Time) { + mm.counter.With("method", "add_report_config").Add(1) + mm.latency.With("method", "add_report_config").Observe(time.Since(begin).Seconds()) + }(time.Now()) + + return mm.service.AddReportConfig(ctx, session, cfg) +} + +func (mm *metricsMiddleware) ViewReportConfig(ctx context.Context, session authn.Session, id string, withRoles bool) (reports.ReportConfig, error) { + defer func(begin time.Time) { + mm.counter.With("method", "view_report_config").Add(1) + mm.latency.With("method", "view_report_config").Observe(time.Since(begin).Seconds()) + }(time.Now()) + + return mm.service.ViewReportConfig(ctx, session, id, withRoles) +} + +func (mm *metricsMiddleware) UpdateReportConfig(ctx context.Context, session authn.Session, cfg reports.ReportConfig) (reports.ReportConfig, error) { + defer func(begin time.Time) { + mm.counter.With("method", "update_report_config").Add(1) + mm.latency.With("method", "update_report_config").Observe(time.Since(begin).Seconds()) + }(time.Now()) + + return mm.service.UpdateReportConfig(ctx, session, cfg) +} + +func (mm *metricsMiddleware) UpdateReportSchedule(ctx context.Context, session authn.Session, cfg reports.ReportConfig) (reports.ReportConfig, error) { + defer func(begin time.Time) { + mm.counter.With("method", "update_report_schedule").Add(1) + mm.latency.With("method", "update_report_schedule").Observe(time.Since(begin).Seconds()) + }(time.Now()) + + return mm.service.UpdateReportSchedule(ctx, session, cfg) +} + +func (mm *metricsMiddleware) RemoveReportConfig(ctx context.Context, session authn.Session, id string) error { + defer func(begin time.Time) { + mm.counter.With("method", "remove_report_config").Add(1) + mm.latency.With("method", "remove_report_config").Observe(time.Since(begin).Seconds()) + }(time.Now()) + + return mm.service.RemoveReportConfig(ctx, session, id) +} + +func (mm *metricsMiddleware) ListReportsConfig(ctx context.Context, session authn.Session, pm reports.PageMeta) (reports.ReportConfigPage, error) { + defer func(begin time.Time) { + mm.counter.With("method", "list_reports_config").Add(1) + mm.latency.With("method", "list_reports_config").Observe(time.Since(begin).Seconds()) + }(time.Now()) + + return mm.service.ListReportsConfig(ctx, session, pm) +} + +func (mm *metricsMiddleware) EnableReportConfig(ctx context.Context, session authn.Session, id string) (reports.ReportConfig, error) { + defer func(begin time.Time) { + mm.counter.With("method", "enable_report_config").Add(1) + mm.latency.With("method", "enable_report_config").Observe(time.Since(begin).Seconds()) + }(time.Now()) + + return mm.service.EnableReportConfig(ctx, session, id) +} + +func (mm *metricsMiddleware) DisableReportConfig(ctx context.Context, session authn.Session, id string) (reports.ReportConfig, error) { + defer func(begin time.Time) { + mm.counter.With("method", "disable_report_config").Add(1) + mm.latency.With("method", "disable_report_config").Observe(time.Since(begin).Seconds()) + }(time.Now()) + + return mm.service.DisableReportConfig(ctx, session, id) +} + +func (mm *metricsMiddleware) UpdateReportTemplate(ctx context.Context, session authn.Session, cfg reports.ReportConfig) error { + defer func(begin time.Time) { + mm.counter.With("method", "update_report_template").Add(1) + mm.latency.With("method", "update_report_template").Observe(time.Since(begin).Seconds()) + }(time.Now()) + + return mm.service.UpdateReportTemplate(ctx, session, cfg) +} + +func (mm *metricsMiddleware) ViewReportTemplate(ctx context.Context, session authn.Session, id string) (reports.ReportTemplate, error) { + defer func(begin time.Time) { + mm.counter.With("method", "view_report_template").Add(1) + mm.latency.With("method", "view_report_template").Observe(time.Since(begin).Seconds()) + }(time.Now()) + + return mm.service.ViewReportTemplate(ctx, session, id) +} + +func (mm *metricsMiddleware) DeleteReportTemplate(ctx context.Context, session authn.Session, id string) error { + defer func(begin time.Time) { + mm.counter.With("method", "delete_report_template").Add(1) + mm.latency.With("method", "delete_report_template").Observe(time.Since(begin).Seconds()) + }(time.Now()) + + return mm.service.DeleteReportTemplate(ctx, session, id) +} + +func (mm *metricsMiddleware) GenerateReport(ctx context.Context, session authn.Session, config reports.ReportConfig, action reports.ReportAction) (reports.ReportPage, error) { + defer func(begin time.Time) { + mm.counter.With("method", "generate_report").Add(1) + mm.latency.With("method", "generate_report").Observe(time.Since(begin).Seconds()) + }(time.Now()) + + return mm.service.GenerateReport(ctx, session, config, action) +} + +func (mm *metricsMiddleware) StartScheduler(ctx context.Context) error { + defer func(begin time.Time) { + mm.counter.With("method", "start_scheduler").Add(1) + mm.latency.With("method", "start_scheduler").Observe(time.Since(begin).Seconds()) + }(time.Now()) + + return mm.service.StartScheduler(ctx) +} diff --git a/reports/middleware/tracing.go b/reports/middleware/tracing.go new file mode 100644 index 000000000..e3c6b49dc --- /dev/null +++ b/reports/middleware/tracing.go @@ -0,0 +1,149 @@ +// Copyright (c) Abstract Machines +// SPDX-License-Identifier: Apache-2.0 + +package middleware + +import ( + "context" + + "github.com/absmach/magistrala/reports" + "github.com/absmach/supermq/pkg/authn" + rolemw "github.com/absmach/supermq/pkg/roles/rolemanager/middleware" + smqTracing "github.com/absmach/supermq/pkg/tracing" + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/trace" +) + +type tracingMiddleware struct { + tracer trace.Tracer + svc reports.Service + rolemw.RoleManagerTracing +} + +var _ reports.Service = (*tracingMiddleware)(nil) + +func NewTracingMiddleware(tracer trace.Tracer, svc reports.Service) reports.Service { + return &tracingMiddleware{ + tracer: tracer, + svc: svc, + RoleManagerTracing: rolemw.NewTracing("reports", svc, tracer), + } +} + +func (tm *tracingMiddleware) AddReportConfig(ctx context.Context, session authn.Session, cfg reports.ReportConfig) (reports.ReportConfig, error) { + ctx, span := smqTracing.StartSpan(ctx, tm.tracer, "add_report_config", trace.WithAttributes( + attribute.String("name", cfg.Name), + attribute.String("domain_id", cfg.DomainID), + )) + defer span.End() + + return tm.svc.AddReportConfig(ctx, session, cfg) +} + +func (tm *tracingMiddleware) ViewReportConfig(ctx context.Context, session authn.Session, id string, withRoles bool) (reports.ReportConfig, error) { + ctx, span := smqTracing.StartSpan(ctx, tm.tracer, "view_report_config", trace.WithAttributes( + attribute.String("id", id), + )) + defer span.End() + + return tm.svc.ViewReportConfig(ctx, session, id, withRoles) +} + +func (tm *tracingMiddleware) UpdateReportConfig(ctx context.Context, session authn.Session, cfg reports.ReportConfig) (reports.ReportConfig, error) { + ctx, span := smqTracing.StartSpan(ctx, tm.tracer, "update_report_config", trace.WithAttributes( + attribute.String("id", cfg.ID), + )) + defer span.End() + + return tm.svc.UpdateReportConfig(ctx, session, cfg) +} + +func (tm *tracingMiddleware) UpdateReportSchedule(ctx context.Context, session authn.Session, cfg reports.ReportConfig) (reports.ReportConfig, error) { + ctx, span := smqTracing.StartSpan(ctx, tm.tracer, "update_report_schedule", trace.WithAttributes( + attribute.String("id", cfg.ID), + )) + defer span.End() + + return tm.svc.UpdateReportSchedule(ctx, session, cfg) +} + +func (tm *tracingMiddleware) RemoveReportConfig(ctx context.Context, session authn.Session, id string) error { + ctx, span := smqTracing.StartSpan(ctx, tm.tracer, "remove_report_config", trace.WithAttributes( + attribute.String("id", id), + )) + defer span.End() + + return tm.svc.RemoveReportConfig(ctx, session, id) +} + +func (tm *tracingMiddleware) ListReportsConfig(ctx context.Context, session authn.Session, pm reports.PageMeta) (reports.ReportConfigPage, error) { + ctx, span := smqTracing.StartSpan(ctx, tm.tracer, "list_reports_config", trace.WithAttributes( + attribute.Int("offset", int(pm.Offset)), + attribute.Int("limit", int(pm.Limit)), + )) + defer span.End() + + return tm.svc.ListReportsConfig(ctx, session, pm) +} + +func (tm *tracingMiddleware) EnableReportConfig(ctx context.Context, session authn.Session, id string) (reports.ReportConfig, error) { + ctx, span := smqTracing.StartSpan(ctx, tm.tracer, "enable_report_config", trace.WithAttributes( + attribute.String("id", id), + )) + defer span.End() + + return tm.svc.EnableReportConfig(ctx, session, id) +} + +func (tm *tracingMiddleware) DisableReportConfig(ctx context.Context, session authn.Session, id string) (reports.ReportConfig, error) { + ctx, span := smqTracing.StartSpan(ctx, tm.tracer, "disable_report_config", trace.WithAttributes( + attribute.String("id", id), + )) + defer span.End() + + return tm.svc.DisableReportConfig(ctx, session, id) +} + +func (tm *tracingMiddleware) UpdateReportTemplate(ctx context.Context, session authn.Session, cfg reports.ReportConfig) error { + ctx, span := smqTracing.StartSpan(ctx, tm.tracer, "update_report_template", trace.WithAttributes( + attribute.String("id", cfg.ID), + )) + defer span.End() + + return tm.svc.UpdateReportTemplate(ctx, session, cfg) +} + +func (tm *tracingMiddleware) ViewReportTemplate(ctx context.Context, session authn.Session, id string) (reports.ReportTemplate, error) { + ctx, span := smqTracing.StartSpan(ctx, tm.tracer, "view_report_template", trace.WithAttributes( + attribute.String("id", id), + )) + defer span.End() + + return tm.svc.ViewReportTemplate(ctx, session, id) +} + +func (tm *tracingMiddleware) DeleteReportTemplate(ctx context.Context, session authn.Session, id string) error { + ctx, span := smqTracing.StartSpan(ctx, tm.tracer, "delete_report_template", trace.WithAttributes( + attribute.String("id", id), + )) + defer span.End() + + return tm.svc.DeleteReportTemplate(ctx, session, id) +} + +func (tm *tracingMiddleware) GenerateReport(ctx context.Context, session authn.Session, config reports.ReportConfig, action reports.ReportAction) (reports.ReportPage, error) { + ctx, span := smqTracing.StartSpan(ctx, tm.tracer, "generate_report", trace.WithAttributes( + attribute.String("config_id", config.ID), + attribute.String("action", string(action)), + )) + defer span.End() + + return tm.svc.GenerateReport(ctx, session, config, action) +} + +func (tm *tracingMiddleware) StartScheduler(ctx context.Context) error { + ctx, span := smqTracing.StartSpan(ctx, tm.tracer, "start_scheduler") + defer span.End() + + return tm.svc.StartScheduler(ctx) +} diff --git a/reports/mocks/repository.go b/reports/mocks/repository.go index af8665c36..8d9e1905d 100644 --- a/reports/mocks/repository.go +++ b/reports/mocks/repository.go @@ -13,6 +13,7 @@ import ( "time" "github.com/absmach/magistrala/reports" + "github.com/absmach/supermq/pkg/roles" mock "github.com/stretchr/testify/mock" ) @@ -109,6 +110,74 @@ func (_c *Repository_AddReportConfig_Call) RunAndReturn(run func(ctx context.Con return _c } +// AddRoles provides a mock function for the type Repository +func (_mock *Repository) AddRoles(ctx context.Context, rps []roles.RoleProvision) ([]roles.RoleProvision, error) { + ret := _mock.Called(ctx, rps) + + if len(ret) == 0 { + panic("no return value specified for AddRoles") + } + + var r0 []roles.RoleProvision + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, []roles.RoleProvision) ([]roles.RoleProvision, error)); ok { + return returnFunc(ctx, rps) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, []roles.RoleProvision) []roles.RoleProvision); ok { + r0 = returnFunc(ctx, rps) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]roles.RoleProvision) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, []roles.RoleProvision) error); ok { + r1 = returnFunc(ctx, rps) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Repository_AddRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddRoles' +type Repository_AddRoles_Call struct { + *mock.Call +} + +// AddRoles is a helper method to define mock.On call +// - ctx context.Context +// - rps []roles.RoleProvision +func (_e *Repository_Expecter) AddRoles(ctx interface{}, rps interface{}) *Repository_AddRoles_Call { + return &Repository_AddRoles_Call{Call: _e.mock.On("AddRoles", ctx, rps)} +} + +func (_c *Repository_AddRoles_Call) Run(run func(ctx context.Context, rps []roles.RoleProvision)) *Repository_AddRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 []roles.RoleProvision + if args[1] != nil { + arg1 = args[1].([]roles.RoleProvision) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Repository_AddRoles_Call) Return(roleProvisions []roles.RoleProvision, err error) *Repository_AddRoles_Call { + _c.Call.Return(roleProvisions, err) + return _c +} + +func (_c *Repository_AddRoles_Call) RunAndReturn(run func(ctx context.Context, rps []roles.RoleProvision) ([]roles.RoleProvision, error)) *Repository_AddRoles_Call { + _c.Call.Return(run) + return _c +} + // DeleteReportTemplate provides a mock function for the type Repository func (_mock *Repository) DeleteReportTemplate(ctx context.Context, domainID string, reportID string) error { ret := _mock.Called(ctx, domainID, reportID) @@ -172,6 +241,78 @@ func (_c *Repository_DeleteReportTemplate_Call) RunAndReturn(run func(ctx contex return _c } +// ListEntityMembers provides a mock function for the type Repository +func (_mock *Repository) ListEntityMembers(ctx context.Context, entityID string, pageQuery roles.MembersRolePageQuery) (roles.MembersRolePage, error) { + ret := _mock.Called(ctx, entityID, pageQuery) + + if len(ret) == 0 { + panic("no return value specified for ListEntityMembers") + } + + var r0 roles.MembersRolePage + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, roles.MembersRolePageQuery) (roles.MembersRolePage, error)); ok { + return returnFunc(ctx, entityID, pageQuery) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string, roles.MembersRolePageQuery) roles.MembersRolePage); ok { + r0 = returnFunc(ctx, entityID, pageQuery) + } else { + r0 = ret.Get(0).(roles.MembersRolePage) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string, roles.MembersRolePageQuery) error); ok { + r1 = returnFunc(ctx, entityID, pageQuery) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Repository_ListEntityMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListEntityMembers' +type Repository_ListEntityMembers_Call struct { + *mock.Call +} + +// ListEntityMembers is a helper method to define mock.On call +// - ctx context.Context +// - entityID string +// - pageQuery roles.MembersRolePageQuery +func (_e *Repository_Expecter) ListEntityMembers(ctx interface{}, entityID interface{}, pageQuery interface{}) *Repository_ListEntityMembers_Call { + return &Repository_ListEntityMembers_Call{Call: _e.mock.On("ListEntityMembers", ctx, entityID, pageQuery)} +} + +func (_c *Repository_ListEntityMembers_Call) Run(run func(ctx context.Context, entityID string, pageQuery roles.MembersRolePageQuery)) *Repository_ListEntityMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 roles.MembersRolePageQuery + if args[2] != nil { + arg2 = args[2].(roles.MembersRolePageQuery) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Repository_ListEntityMembers_Call) Return(membersRolePage roles.MembersRolePage, err error) *Repository_ListEntityMembers_Call { + _c.Call.Return(membersRolePage, err) + return _c +} + +func (_c *Repository_ListEntityMembers_Call) RunAndReturn(run func(ctx context.Context, entityID string, pageQuery roles.MembersRolePageQuery) (roles.MembersRolePage, error)) *Repository_ListEntityMembers_Call { + _c.Call.Return(run) + return _c +} + // ListReportsConfig provides a mock function for the type Repository func (_mock *Repository) ListReportsConfig(ctx context.Context, pm reports.PageMeta) (reports.ReportConfigPage, error) { ret := _mock.Called(ctx, pm) @@ -238,6 +379,126 @@ func (_c *Repository_ListReportsConfig_Call) RunAndReturn(run func(ctx context.C return _c } +// RemoveEntityMembers provides a mock function for the type Repository +func (_mock *Repository) RemoveEntityMembers(ctx context.Context, entityID string, members []string) error { + ret := _mock.Called(ctx, entityID, members) + + if len(ret) == 0 { + panic("no return value specified for RemoveEntityMembers") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string) error); ok { + r0 = returnFunc(ctx, entityID, members) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Repository_RemoveEntityMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveEntityMembers' +type Repository_RemoveEntityMembers_Call struct { + *mock.Call +} + +// RemoveEntityMembers is a helper method to define mock.On call +// - ctx context.Context +// - entityID string +// - members []string +func (_e *Repository_Expecter) RemoveEntityMembers(ctx interface{}, entityID interface{}, members interface{}) *Repository_RemoveEntityMembers_Call { + return &Repository_RemoveEntityMembers_Call{Call: _e.mock.On("RemoveEntityMembers", ctx, entityID, members)} +} + +func (_c *Repository_RemoveEntityMembers_Call) Run(run func(ctx context.Context, entityID string, members []string)) *Repository_RemoveEntityMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 []string + if args[2] != nil { + arg2 = args[2].([]string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Repository_RemoveEntityMembers_Call) Return(err error) *Repository_RemoveEntityMembers_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Repository_RemoveEntityMembers_Call) RunAndReturn(run func(ctx context.Context, entityID string, members []string) error) *Repository_RemoveEntityMembers_Call { + _c.Call.Return(run) + return _c +} + +// RemoveMemberFromAllRoles provides a mock function for the type Repository +func (_mock *Repository) RemoveMemberFromAllRoles(ctx context.Context, memberID string) error { + ret := _mock.Called(ctx, memberID) + + if len(ret) == 0 { + panic("no return value specified for RemoveMemberFromAllRoles") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok { + r0 = returnFunc(ctx, memberID) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Repository_RemoveMemberFromAllRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMemberFromAllRoles' +type Repository_RemoveMemberFromAllRoles_Call struct { + *mock.Call +} + +// RemoveMemberFromAllRoles is a helper method to define mock.On call +// - ctx context.Context +// - memberID string +func (_e *Repository_Expecter) RemoveMemberFromAllRoles(ctx interface{}, memberID interface{}) *Repository_RemoveMemberFromAllRoles_Call { + return &Repository_RemoveMemberFromAllRoles_Call{Call: _e.mock.On("RemoveMemberFromAllRoles", ctx, memberID)} +} + +func (_c *Repository_RemoveMemberFromAllRoles_Call) Run(run func(ctx context.Context, memberID string)) *Repository_RemoveMemberFromAllRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Repository_RemoveMemberFromAllRoles_Call) Return(err error) *Repository_RemoveMemberFromAllRoles_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Repository_RemoveMemberFromAllRoles_Call) RunAndReturn(run func(ctx context.Context, memberID string) error) *Repository_RemoveMemberFromAllRoles_Call { + _c.Call.Return(run) + return _c +} + // RemoveReportConfig provides a mock function for the type Repository func (_mock *Repository) RemoveReportConfig(ctx context.Context, id string) error { ret := _mock.Called(ctx, id) @@ -295,6 +556,1105 @@ func (_c *Repository_RemoveReportConfig_Call) RunAndReturn(run func(ctx context. return _c } +// RemoveRoles provides a mock function for the type Repository +func (_mock *Repository) RemoveRoles(ctx context.Context, roleIDs []string) error { + ret := _mock.Called(ctx, roleIDs) + + if len(ret) == 0 { + panic("no return value specified for RemoveRoles") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, []string) error); ok { + r0 = returnFunc(ctx, roleIDs) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Repository_RemoveRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRoles' +type Repository_RemoveRoles_Call struct { + *mock.Call +} + +// RemoveRoles is a helper method to define mock.On call +// - ctx context.Context +// - roleIDs []string +func (_e *Repository_Expecter) RemoveRoles(ctx interface{}, roleIDs interface{}) *Repository_RemoveRoles_Call { + return &Repository_RemoveRoles_Call{Call: _e.mock.On("RemoveRoles", ctx, roleIDs)} +} + +func (_c *Repository_RemoveRoles_Call) Run(run func(ctx context.Context, roleIDs []string)) *Repository_RemoveRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 []string + if args[1] != nil { + arg1 = args[1].([]string) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Repository_RemoveRoles_Call) Return(err error) *Repository_RemoveRoles_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Repository_RemoveRoles_Call) RunAndReturn(run func(ctx context.Context, roleIDs []string) error) *Repository_RemoveRoles_Call { + _c.Call.Return(run) + return _c +} + +// RetrieveAllRoles provides a mock function for the type Repository +func (_mock *Repository) RetrieveAllRoles(ctx context.Context, entityID string, limit uint64, offset uint64) (roles.RolePage, error) { + ret := _mock.Called(ctx, entityID, limit, offset) + + if len(ret) == 0 { + panic("no return value specified for RetrieveAllRoles") + } + + var r0 roles.RolePage + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, uint64, uint64) (roles.RolePage, error)); ok { + return returnFunc(ctx, entityID, limit, offset) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string, uint64, uint64) roles.RolePage); ok { + r0 = returnFunc(ctx, entityID, limit, offset) + } else { + r0 = ret.Get(0).(roles.RolePage) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string, uint64, uint64) error); ok { + r1 = returnFunc(ctx, entityID, limit, offset) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Repository_RetrieveAllRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveAllRoles' +type Repository_RetrieveAllRoles_Call struct { + *mock.Call +} + +// RetrieveAllRoles is a helper method to define mock.On call +// - ctx context.Context +// - entityID string +// - limit uint64 +// - offset uint64 +func (_e *Repository_Expecter) RetrieveAllRoles(ctx interface{}, entityID interface{}, limit interface{}, offset interface{}) *Repository_RetrieveAllRoles_Call { + return &Repository_RetrieveAllRoles_Call{Call: _e.mock.On("RetrieveAllRoles", ctx, entityID, limit, offset)} +} + +func (_c *Repository_RetrieveAllRoles_Call) Run(run func(ctx context.Context, entityID string, limit uint64, offset uint64)) *Repository_RetrieveAllRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 uint64 + if args[2] != nil { + arg2 = args[2].(uint64) + } + var arg3 uint64 + if args[3] != nil { + arg3 = args[3].(uint64) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *Repository_RetrieveAllRoles_Call) Return(rolePage roles.RolePage, err error) *Repository_RetrieveAllRoles_Call { + _c.Call.Return(rolePage, err) + return _c +} + +func (_c *Repository_RetrieveAllRoles_Call) RunAndReturn(run func(ctx context.Context, entityID string, limit uint64, offset uint64) (roles.RolePage, error)) *Repository_RetrieveAllRoles_Call { + _c.Call.Return(run) + return _c +} + +// RetrieveByIDWithRoles provides a mock function for the type Repository +func (_mock *Repository) RetrieveByIDWithRoles(ctx context.Context, id string, memberID string) (reports.ReportConfig, error) { + ret := _mock.Called(ctx, id, memberID) + + if len(ret) == 0 { + panic("no return value specified for RetrieveByIDWithRoles") + } + + var r0 reports.ReportConfig + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (reports.ReportConfig, error)); ok { + return returnFunc(ctx, id, memberID) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) reports.ReportConfig); ok { + r0 = returnFunc(ctx, id, memberID) + } else { + r0 = ret.Get(0).(reports.ReportConfig) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok { + r1 = returnFunc(ctx, id, memberID) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Repository_RetrieveByIDWithRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveByIDWithRoles' +type Repository_RetrieveByIDWithRoles_Call struct { + *mock.Call +} + +// RetrieveByIDWithRoles is a helper method to define mock.On call +// - ctx context.Context +// - id string +// - memberID string +func (_e *Repository_Expecter) RetrieveByIDWithRoles(ctx interface{}, id interface{}, memberID interface{}) *Repository_RetrieveByIDWithRoles_Call { + return &Repository_RetrieveByIDWithRoles_Call{Call: _e.mock.On("RetrieveByIDWithRoles", ctx, id, memberID)} +} + +func (_c *Repository_RetrieveByIDWithRoles_Call) Run(run func(ctx context.Context, id string, memberID string)) *Repository_RetrieveByIDWithRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Repository_RetrieveByIDWithRoles_Call) Return(reportConfig reports.ReportConfig, err error) *Repository_RetrieveByIDWithRoles_Call { + _c.Call.Return(reportConfig, err) + return _c +} + +func (_c *Repository_RetrieveByIDWithRoles_Call) RunAndReturn(run func(ctx context.Context, id string, memberID string) (reports.ReportConfig, error)) *Repository_RetrieveByIDWithRoles_Call { + _c.Call.Return(run) + return _c +} + +// RetrieveEntitiesRolesActionsMembers provides a mock function for the type Repository +func (_mock *Repository) RetrieveEntitiesRolesActionsMembers(ctx context.Context, entityIDs []string) ([]roles.EntityActionRole, []roles.EntityMemberRole, error) { + ret := _mock.Called(ctx, entityIDs) + + if len(ret) == 0 { + panic("no return value specified for RetrieveEntitiesRolesActionsMembers") + } + + var r0 []roles.EntityActionRole + var r1 []roles.EntityMemberRole + var r2 error + if returnFunc, ok := ret.Get(0).(func(context.Context, []string) ([]roles.EntityActionRole, []roles.EntityMemberRole, error)); ok { + return returnFunc(ctx, entityIDs) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, []string) []roles.EntityActionRole); ok { + r0 = returnFunc(ctx, entityIDs) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]roles.EntityActionRole) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, []string) []roles.EntityMemberRole); ok { + r1 = returnFunc(ctx, entityIDs) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).([]roles.EntityMemberRole) + } + } + if returnFunc, ok := ret.Get(2).(func(context.Context, []string) error); ok { + r2 = returnFunc(ctx, entityIDs) + } else { + r2 = ret.Error(2) + } + return r0, r1, r2 +} + +// Repository_RetrieveEntitiesRolesActionsMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveEntitiesRolesActionsMembers' +type Repository_RetrieveEntitiesRolesActionsMembers_Call struct { + *mock.Call +} + +// RetrieveEntitiesRolesActionsMembers is a helper method to define mock.On call +// - ctx context.Context +// - entityIDs []string +func (_e *Repository_Expecter) RetrieveEntitiesRolesActionsMembers(ctx interface{}, entityIDs interface{}) *Repository_RetrieveEntitiesRolesActionsMembers_Call { + return &Repository_RetrieveEntitiesRolesActionsMembers_Call{Call: _e.mock.On("RetrieveEntitiesRolesActionsMembers", ctx, entityIDs)} +} + +func (_c *Repository_RetrieveEntitiesRolesActionsMembers_Call) Run(run func(ctx context.Context, entityIDs []string)) *Repository_RetrieveEntitiesRolesActionsMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 []string + if args[1] != nil { + arg1 = args[1].([]string) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Repository_RetrieveEntitiesRolesActionsMembers_Call) Return(entityActionRoles []roles.EntityActionRole, entityMemberRoles []roles.EntityMemberRole, err error) *Repository_RetrieveEntitiesRolesActionsMembers_Call { + _c.Call.Return(entityActionRoles, entityMemberRoles, err) + return _c +} + +func (_c *Repository_RetrieveEntitiesRolesActionsMembers_Call) RunAndReturn(run func(ctx context.Context, entityIDs []string) ([]roles.EntityActionRole, []roles.EntityMemberRole, error)) *Repository_RetrieveEntitiesRolesActionsMembers_Call { + _c.Call.Return(run) + return _c +} + +// RetrieveEntityRole provides a mock function for the type Repository +func (_mock *Repository) RetrieveEntityRole(ctx context.Context, entityID string, roleID string) (roles.Role, error) { + ret := _mock.Called(ctx, entityID, roleID) + + if len(ret) == 0 { + panic("no return value specified for RetrieveEntityRole") + } + + var r0 roles.Role + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (roles.Role, error)); ok { + return returnFunc(ctx, entityID, roleID) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) roles.Role); ok { + r0 = returnFunc(ctx, entityID, roleID) + } else { + r0 = ret.Get(0).(roles.Role) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok { + r1 = returnFunc(ctx, entityID, roleID) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Repository_RetrieveEntityRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveEntityRole' +type Repository_RetrieveEntityRole_Call struct { + *mock.Call +} + +// RetrieveEntityRole is a helper method to define mock.On call +// - ctx context.Context +// - entityID string +// - roleID string +func (_e *Repository_Expecter) RetrieveEntityRole(ctx interface{}, entityID interface{}, roleID interface{}) *Repository_RetrieveEntityRole_Call { + return &Repository_RetrieveEntityRole_Call{Call: _e.mock.On("RetrieveEntityRole", ctx, entityID, roleID)} +} + +func (_c *Repository_RetrieveEntityRole_Call) Run(run func(ctx context.Context, entityID string, roleID string)) *Repository_RetrieveEntityRole_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Repository_RetrieveEntityRole_Call) Return(role roles.Role, err error) *Repository_RetrieveEntityRole_Call { + _c.Call.Return(role, err) + return _c +} + +func (_c *Repository_RetrieveEntityRole_Call) RunAndReturn(run func(ctx context.Context, entityID string, roleID string) (roles.Role, error)) *Repository_RetrieveEntityRole_Call { + _c.Call.Return(run) + return _c +} + +// RetrieveRole provides a mock function for the type Repository +func (_mock *Repository) RetrieveRole(ctx context.Context, roleID string) (roles.Role, error) { + ret := _mock.Called(ctx, roleID) + + if len(ret) == 0 { + panic("no return value specified for RetrieveRole") + } + + var r0 roles.Role + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string) (roles.Role, error)); ok { + return returnFunc(ctx, roleID) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string) roles.Role); ok { + r0 = returnFunc(ctx, roleID) + } else { + r0 = ret.Get(0).(roles.Role) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = returnFunc(ctx, roleID) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Repository_RetrieveRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveRole' +type Repository_RetrieveRole_Call struct { + *mock.Call +} + +// RetrieveRole is a helper method to define mock.On call +// - ctx context.Context +// - roleID string +func (_e *Repository_Expecter) RetrieveRole(ctx interface{}, roleID interface{}) *Repository_RetrieveRole_Call { + return &Repository_RetrieveRole_Call{Call: _e.mock.On("RetrieveRole", ctx, roleID)} +} + +func (_c *Repository_RetrieveRole_Call) Run(run func(ctx context.Context, roleID string)) *Repository_RetrieveRole_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Repository_RetrieveRole_Call) Return(role roles.Role, err error) *Repository_RetrieveRole_Call { + _c.Call.Return(role, err) + return _c +} + +func (_c *Repository_RetrieveRole_Call) RunAndReturn(run func(ctx context.Context, roleID string) (roles.Role, error)) *Repository_RetrieveRole_Call { + _c.Call.Return(run) + return _c +} + +// RoleAddActions provides a mock function for the type Repository +func (_mock *Repository) RoleAddActions(ctx context.Context, role roles.Role, actions []string) ([]string, error) { + ret := _mock.Called(ctx, role, actions) + + if len(ret) == 0 { + panic("no return value specified for RoleAddActions") + } + + var r0 []string + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, roles.Role, []string) ([]string, error)); ok { + return returnFunc(ctx, role, actions) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, roles.Role, []string) []string); ok { + r0 = returnFunc(ctx, role, actions) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, roles.Role, []string) error); ok { + r1 = returnFunc(ctx, role, actions) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Repository_RoleAddActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleAddActions' +type Repository_RoleAddActions_Call struct { + *mock.Call +} + +// RoleAddActions is a helper method to define mock.On call +// - ctx context.Context +// - role roles.Role +// - actions []string +func (_e *Repository_Expecter) RoleAddActions(ctx interface{}, role interface{}, actions interface{}) *Repository_RoleAddActions_Call { + return &Repository_RoleAddActions_Call{Call: _e.mock.On("RoleAddActions", ctx, role, actions)} +} + +func (_c *Repository_RoleAddActions_Call) Run(run func(ctx context.Context, role roles.Role, actions []string)) *Repository_RoleAddActions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 roles.Role + if args[1] != nil { + arg1 = args[1].(roles.Role) + } + var arg2 []string + if args[2] != nil { + arg2 = args[2].([]string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Repository_RoleAddActions_Call) Return(ops []string, err error) *Repository_RoleAddActions_Call { + _c.Call.Return(ops, err) + return _c +} + +func (_c *Repository_RoleAddActions_Call) RunAndReturn(run func(ctx context.Context, role roles.Role, actions []string) ([]string, error)) *Repository_RoleAddActions_Call { + _c.Call.Return(run) + return _c +} + +// RoleAddMembers provides a mock function for the type Repository +func (_mock *Repository) RoleAddMembers(ctx context.Context, role roles.Role, members []string) ([]string, error) { + ret := _mock.Called(ctx, role, members) + + if len(ret) == 0 { + panic("no return value specified for RoleAddMembers") + } + + var r0 []string + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, roles.Role, []string) ([]string, error)); ok { + return returnFunc(ctx, role, members) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, roles.Role, []string) []string); ok { + r0 = returnFunc(ctx, role, members) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, roles.Role, []string) error); ok { + r1 = returnFunc(ctx, role, members) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Repository_RoleAddMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleAddMembers' +type Repository_RoleAddMembers_Call struct { + *mock.Call +} + +// RoleAddMembers is a helper method to define mock.On call +// - ctx context.Context +// - role roles.Role +// - members []string +func (_e *Repository_Expecter) RoleAddMembers(ctx interface{}, role interface{}, members interface{}) *Repository_RoleAddMembers_Call { + return &Repository_RoleAddMembers_Call{Call: _e.mock.On("RoleAddMembers", ctx, role, members)} +} + +func (_c *Repository_RoleAddMembers_Call) Run(run func(ctx context.Context, role roles.Role, members []string)) *Repository_RoleAddMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 roles.Role + if args[1] != nil { + arg1 = args[1].(roles.Role) + } + var arg2 []string + if args[2] != nil { + arg2 = args[2].([]string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Repository_RoleAddMembers_Call) Return(strings []string, err error) *Repository_RoleAddMembers_Call { + _c.Call.Return(strings, err) + return _c +} + +func (_c *Repository_RoleAddMembers_Call) RunAndReturn(run func(ctx context.Context, role roles.Role, members []string) ([]string, error)) *Repository_RoleAddMembers_Call { + _c.Call.Return(run) + return _c +} + +// RoleCheckActionsExists provides a mock function for the type Repository +func (_mock *Repository) RoleCheckActionsExists(ctx context.Context, roleID string, actions []string) (bool, error) { + ret := _mock.Called(ctx, roleID, actions) + + if len(ret) == 0 { + panic("no return value specified for RoleCheckActionsExists") + } + + var r0 bool + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string) (bool, error)); ok { + return returnFunc(ctx, roleID, actions) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string) bool); ok { + r0 = returnFunc(ctx, roleID, actions) + } else { + r0 = ret.Get(0).(bool) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string, []string) error); ok { + r1 = returnFunc(ctx, roleID, actions) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Repository_RoleCheckActionsExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleCheckActionsExists' +type Repository_RoleCheckActionsExists_Call struct { + *mock.Call +} + +// RoleCheckActionsExists is a helper method to define mock.On call +// - ctx context.Context +// - roleID string +// - actions []string +func (_e *Repository_Expecter) RoleCheckActionsExists(ctx interface{}, roleID interface{}, actions interface{}) *Repository_RoleCheckActionsExists_Call { + return &Repository_RoleCheckActionsExists_Call{Call: _e.mock.On("RoleCheckActionsExists", ctx, roleID, actions)} +} + +func (_c *Repository_RoleCheckActionsExists_Call) Run(run func(ctx context.Context, roleID string, actions []string)) *Repository_RoleCheckActionsExists_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 []string + if args[2] != nil { + arg2 = args[2].([]string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Repository_RoleCheckActionsExists_Call) Return(b bool, err error) *Repository_RoleCheckActionsExists_Call { + _c.Call.Return(b, err) + return _c +} + +func (_c *Repository_RoleCheckActionsExists_Call) RunAndReturn(run func(ctx context.Context, roleID string, actions []string) (bool, error)) *Repository_RoleCheckActionsExists_Call { + _c.Call.Return(run) + return _c +} + +// RoleCheckMembersExists provides a mock function for the type Repository +func (_mock *Repository) RoleCheckMembersExists(ctx context.Context, roleID string, members []string) (bool, error) { + ret := _mock.Called(ctx, roleID, members) + + if len(ret) == 0 { + panic("no return value specified for RoleCheckMembersExists") + } + + var r0 bool + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string) (bool, error)); ok { + return returnFunc(ctx, roleID, members) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string, []string) bool); ok { + r0 = returnFunc(ctx, roleID, members) + } else { + r0 = ret.Get(0).(bool) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string, []string) error); ok { + r1 = returnFunc(ctx, roleID, members) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Repository_RoleCheckMembersExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleCheckMembersExists' +type Repository_RoleCheckMembersExists_Call struct { + *mock.Call +} + +// RoleCheckMembersExists is a helper method to define mock.On call +// - ctx context.Context +// - roleID string +// - members []string +func (_e *Repository_Expecter) RoleCheckMembersExists(ctx interface{}, roleID interface{}, members interface{}) *Repository_RoleCheckMembersExists_Call { + return &Repository_RoleCheckMembersExists_Call{Call: _e.mock.On("RoleCheckMembersExists", ctx, roleID, members)} +} + +func (_c *Repository_RoleCheckMembersExists_Call) Run(run func(ctx context.Context, roleID string, members []string)) *Repository_RoleCheckMembersExists_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 []string + if args[2] != nil { + arg2 = args[2].([]string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Repository_RoleCheckMembersExists_Call) Return(b bool, err error) *Repository_RoleCheckMembersExists_Call { + _c.Call.Return(b, err) + return _c +} + +func (_c *Repository_RoleCheckMembersExists_Call) RunAndReturn(run func(ctx context.Context, roleID string, members []string) (bool, error)) *Repository_RoleCheckMembersExists_Call { + _c.Call.Return(run) + return _c +} + +// RoleListActions provides a mock function for the type Repository +func (_mock *Repository) RoleListActions(ctx context.Context, roleID string) ([]string, error) { + ret := _mock.Called(ctx, roleID) + + if len(ret) == 0 { + panic("no return value specified for RoleListActions") + } + + var r0 []string + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]string, error)); ok { + return returnFunc(ctx, roleID) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string) []string); ok { + r0 = returnFunc(ctx, roleID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok { + r1 = returnFunc(ctx, roleID) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Repository_RoleListActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleListActions' +type Repository_RoleListActions_Call struct { + *mock.Call +} + +// RoleListActions is a helper method to define mock.On call +// - ctx context.Context +// - roleID string +func (_e *Repository_Expecter) RoleListActions(ctx interface{}, roleID interface{}) *Repository_RoleListActions_Call { + return &Repository_RoleListActions_Call{Call: _e.mock.On("RoleListActions", ctx, roleID)} +} + +func (_c *Repository_RoleListActions_Call) Run(run func(ctx context.Context, roleID string)) *Repository_RoleListActions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Repository_RoleListActions_Call) Return(strings []string, err error) *Repository_RoleListActions_Call { + _c.Call.Return(strings, err) + return _c +} + +func (_c *Repository_RoleListActions_Call) RunAndReturn(run func(ctx context.Context, roleID string) ([]string, error)) *Repository_RoleListActions_Call { + _c.Call.Return(run) + return _c +} + +// RoleListMembers provides a mock function for the type Repository +func (_mock *Repository) RoleListMembers(ctx context.Context, roleID string, limit uint64, offset uint64) (roles.MembersPage, error) { + ret := _mock.Called(ctx, roleID, limit, offset) + + if len(ret) == 0 { + panic("no return value specified for RoleListMembers") + } + + var r0 roles.MembersPage + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, uint64, uint64) (roles.MembersPage, error)); ok { + return returnFunc(ctx, roleID, limit, offset) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string, uint64, uint64) roles.MembersPage); ok { + r0 = returnFunc(ctx, roleID, limit, offset) + } else { + r0 = ret.Get(0).(roles.MembersPage) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string, uint64, uint64) error); ok { + r1 = returnFunc(ctx, roleID, limit, offset) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Repository_RoleListMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleListMembers' +type Repository_RoleListMembers_Call struct { + *mock.Call +} + +// RoleListMembers is a helper method to define mock.On call +// - ctx context.Context +// - roleID string +// - limit uint64 +// - offset uint64 +func (_e *Repository_Expecter) RoleListMembers(ctx interface{}, roleID interface{}, limit interface{}, offset interface{}) *Repository_RoleListMembers_Call { + return &Repository_RoleListMembers_Call{Call: _e.mock.On("RoleListMembers", ctx, roleID, limit, offset)} +} + +func (_c *Repository_RoleListMembers_Call) Run(run func(ctx context.Context, roleID string, limit uint64, offset uint64)) *Repository_RoleListMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 uint64 + if args[2] != nil { + arg2 = args[2].(uint64) + } + var arg3 uint64 + if args[3] != nil { + arg3 = args[3].(uint64) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *Repository_RoleListMembers_Call) Return(membersPage roles.MembersPage, err error) *Repository_RoleListMembers_Call { + _c.Call.Return(membersPage, err) + return _c +} + +func (_c *Repository_RoleListMembers_Call) RunAndReturn(run func(ctx context.Context, roleID string, limit uint64, offset uint64) (roles.MembersPage, error)) *Repository_RoleListMembers_Call { + _c.Call.Return(run) + return _c +} + +// RoleRemoveActions provides a mock function for the type Repository +func (_mock *Repository) RoleRemoveActions(ctx context.Context, role roles.Role, actions []string) error { + ret := _mock.Called(ctx, role, actions) + + if len(ret) == 0 { + panic("no return value specified for RoleRemoveActions") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, roles.Role, []string) error); ok { + r0 = returnFunc(ctx, role, actions) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Repository_RoleRemoveActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleRemoveActions' +type Repository_RoleRemoveActions_Call struct { + *mock.Call +} + +// RoleRemoveActions is a helper method to define mock.On call +// - ctx context.Context +// - role roles.Role +// - actions []string +func (_e *Repository_Expecter) RoleRemoveActions(ctx interface{}, role interface{}, actions interface{}) *Repository_RoleRemoveActions_Call { + return &Repository_RoleRemoveActions_Call{Call: _e.mock.On("RoleRemoveActions", ctx, role, actions)} +} + +func (_c *Repository_RoleRemoveActions_Call) Run(run func(ctx context.Context, role roles.Role, actions []string)) *Repository_RoleRemoveActions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 roles.Role + if args[1] != nil { + arg1 = args[1].(roles.Role) + } + var arg2 []string + if args[2] != nil { + arg2 = args[2].([]string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Repository_RoleRemoveActions_Call) Return(err error) *Repository_RoleRemoveActions_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Repository_RoleRemoveActions_Call) RunAndReturn(run func(ctx context.Context, role roles.Role, actions []string) error) *Repository_RoleRemoveActions_Call { + _c.Call.Return(run) + return _c +} + +// RoleRemoveAllActions provides a mock function for the type Repository +func (_mock *Repository) RoleRemoveAllActions(ctx context.Context, role roles.Role) error { + ret := _mock.Called(ctx, role) + + if len(ret) == 0 { + panic("no return value specified for RoleRemoveAllActions") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, roles.Role) error); ok { + r0 = returnFunc(ctx, role) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Repository_RoleRemoveAllActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleRemoveAllActions' +type Repository_RoleRemoveAllActions_Call struct { + *mock.Call +} + +// RoleRemoveAllActions is a helper method to define mock.On call +// - ctx context.Context +// - role roles.Role +func (_e *Repository_Expecter) RoleRemoveAllActions(ctx interface{}, role interface{}) *Repository_RoleRemoveAllActions_Call { + return &Repository_RoleRemoveAllActions_Call{Call: _e.mock.On("RoleRemoveAllActions", ctx, role)} +} + +func (_c *Repository_RoleRemoveAllActions_Call) Run(run func(ctx context.Context, role roles.Role)) *Repository_RoleRemoveAllActions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 roles.Role + if args[1] != nil { + arg1 = args[1].(roles.Role) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Repository_RoleRemoveAllActions_Call) Return(err error) *Repository_RoleRemoveAllActions_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Repository_RoleRemoveAllActions_Call) RunAndReturn(run func(ctx context.Context, role roles.Role) error) *Repository_RoleRemoveAllActions_Call { + _c.Call.Return(run) + return _c +} + +// RoleRemoveAllMembers provides a mock function for the type Repository +func (_mock *Repository) RoleRemoveAllMembers(ctx context.Context, role roles.Role) error { + ret := _mock.Called(ctx, role) + + if len(ret) == 0 { + panic("no return value specified for RoleRemoveAllMembers") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, roles.Role) error); ok { + r0 = returnFunc(ctx, role) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Repository_RoleRemoveAllMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleRemoveAllMembers' +type Repository_RoleRemoveAllMembers_Call struct { + *mock.Call +} + +// RoleRemoveAllMembers is a helper method to define mock.On call +// - ctx context.Context +// - role roles.Role +func (_e *Repository_Expecter) RoleRemoveAllMembers(ctx interface{}, role interface{}) *Repository_RoleRemoveAllMembers_Call { + return &Repository_RoleRemoveAllMembers_Call{Call: _e.mock.On("RoleRemoveAllMembers", ctx, role)} +} + +func (_c *Repository_RoleRemoveAllMembers_Call) Run(run func(ctx context.Context, role roles.Role)) *Repository_RoleRemoveAllMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 roles.Role + if args[1] != nil { + arg1 = args[1].(roles.Role) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Repository_RoleRemoveAllMembers_Call) Return(err error) *Repository_RoleRemoveAllMembers_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Repository_RoleRemoveAllMembers_Call) RunAndReturn(run func(ctx context.Context, role roles.Role) error) *Repository_RoleRemoveAllMembers_Call { + _c.Call.Return(run) + return _c +} + +// RoleRemoveMembers provides a mock function for the type Repository +func (_mock *Repository) RoleRemoveMembers(ctx context.Context, role roles.Role, members []string) error { + ret := _mock.Called(ctx, role, members) + + if len(ret) == 0 { + panic("no return value specified for RoleRemoveMembers") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, roles.Role, []string) error); ok { + r0 = returnFunc(ctx, role, members) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Repository_RoleRemoveMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleRemoveMembers' +type Repository_RoleRemoveMembers_Call struct { + *mock.Call +} + +// RoleRemoveMembers is a helper method to define mock.On call +// - ctx context.Context +// - role roles.Role +// - members []string +func (_e *Repository_Expecter) RoleRemoveMembers(ctx interface{}, role interface{}, members interface{}) *Repository_RoleRemoveMembers_Call { + return &Repository_RoleRemoveMembers_Call{Call: _e.mock.On("RoleRemoveMembers", ctx, role, members)} +} + +func (_c *Repository_RoleRemoveMembers_Call) Run(run func(ctx context.Context, role roles.Role, members []string)) *Repository_RoleRemoveMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 roles.Role + if args[1] != nil { + arg1 = args[1].(roles.Role) + } + var arg2 []string + if args[2] != nil { + arg2 = args[2].([]string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Repository_RoleRemoveMembers_Call) Return(err error) *Repository_RoleRemoveMembers_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Repository_RoleRemoveMembers_Call) RunAndReturn(run func(ctx context.Context, role roles.Role, members []string) error) *Repository_RoleRemoveMembers_Call { + _c.Call.Return(run) + return _c +} + // UpdateReportConfig provides a mock function for the type Repository func (_mock *Repository) UpdateReportConfig(ctx context.Context, cfg reports.ReportConfig) (reports.ReportConfig, error) { ret := _mock.Called(ctx, cfg) @@ -634,6 +1994,72 @@ func (_c *Repository_UpdateReportTemplate_Call) RunAndReturn(run func(ctx contex return _c } +// UpdateRole provides a mock function for the type Repository +func (_mock *Repository) UpdateRole(ctx context.Context, ro roles.Role) (roles.Role, error) { + ret := _mock.Called(ctx, ro) + + if len(ret) == 0 { + panic("no return value specified for UpdateRole") + } + + var r0 roles.Role + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, roles.Role) (roles.Role, error)); ok { + return returnFunc(ctx, ro) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, roles.Role) roles.Role); ok { + r0 = returnFunc(ctx, ro) + } else { + r0 = ret.Get(0).(roles.Role) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, roles.Role) error); ok { + r1 = returnFunc(ctx, ro) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Repository_UpdateRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRole' +type Repository_UpdateRole_Call struct { + *mock.Call +} + +// UpdateRole is a helper method to define mock.On call +// - ctx context.Context +// - ro roles.Role +func (_e *Repository_Expecter) UpdateRole(ctx interface{}, ro interface{}) *Repository_UpdateRole_Call { + return &Repository_UpdateRole_Call{Call: _e.mock.On("UpdateRole", ctx, ro)} +} + +func (_c *Repository_UpdateRole_Call) Run(run func(ctx context.Context, ro roles.Role)) *Repository_UpdateRole_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 roles.Role + if args[1] != nil { + arg1 = args[1].(roles.Role) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Repository_UpdateRole_Call) Return(role roles.Role, err error) *Repository_UpdateRole_Call { + _c.Call.Return(role, err) + return _c +} + +func (_c *Repository_UpdateRole_Call) RunAndReturn(run func(ctx context.Context, ro roles.Role) (roles.Role, error)) *Repository_UpdateRole_Call { + _c.Call.Return(run) + return _c +} + // ViewReportConfig provides a mock function for the type Repository func (_mock *Repository) ViewReportConfig(ctx context.Context, id string) (reports.ReportConfig, error) { ret := _mock.Called(ctx, id) diff --git a/reports/mocks/service.go b/reports/mocks/service.go index f56d72b30..951a57da7 100644 --- a/reports/mocks/service.go +++ b/reports/mocks/service.go @@ -13,6 +13,7 @@ import ( "github.com/absmach/magistrala/reports" "github.com/absmach/supermq/pkg/authn" + "github.com/absmach/supermq/pkg/roles" mock "github.com/stretchr/testify/mock" ) @@ -115,6 +116,96 @@ func (_c *Service_AddReportConfig_Call) RunAndReturn(run func(ctx context.Contex return _c } +// AddRole provides a mock function for the type Service +func (_mock *Service) AddRole(ctx context.Context, session authn.Session, entityID string, roleName string, optionalActions []string, optionalMembers []string) (roles.RoleProvision, error) { + ret := _mock.Called(ctx, session, entityID, roleName, optionalActions, optionalMembers) + + if len(ret) == 0 { + panic("no return value specified for AddRole") + } + + var r0 roles.RoleProvision + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, []string, []string) (roles.RoleProvision, error)); ok { + return returnFunc(ctx, session, entityID, roleName, optionalActions, optionalMembers) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, []string, []string) roles.RoleProvision); ok { + r0 = returnFunc(ctx, session, entityID, roleName, optionalActions, optionalMembers) + } else { + r0 = ret.Get(0).(roles.RoleProvision) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string, []string, []string) error); ok { + r1 = returnFunc(ctx, session, entityID, roleName, optionalActions, optionalMembers) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Service_AddRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddRole' +type Service_AddRole_Call struct { + *mock.Call +} + +// AddRole is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleName string +// - optionalActions []string +// - optionalMembers []string +func (_e *Service_Expecter) AddRole(ctx interface{}, session interface{}, entityID interface{}, roleName interface{}, optionalActions interface{}, optionalMembers interface{}) *Service_AddRole_Call { + return &Service_AddRole_Call{Call: _e.mock.On("AddRole", ctx, session, entityID, roleName, optionalActions, optionalMembers)} +} + +func (_c *Service_AddRole_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleName string, optionalActions []string, optionalMembers []string)) *Service_AddRole_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 []string + if args[4] != nil { + arg4 = args[4].([]string) + } + var arg5 []string + if args[5] != nil { + arg5 = args[5].([]string) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + ) + }) + return _c +} + +func (_c *Service_AddRole_Call) Return(roleProvision roles.RoleProvision, err error) *Service_AddRole_Call { + _c.Call.Return(roleProvision, err) + return _c +} + +func (_c *Service_AddRole_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleName string, optionalActions []string, optionalMembers []string) (roles.RoleProvision, error)) *Service_AddRole_Call { + _c.Call.Return(run) + return _c +} + // DeleteReportTemplate provides a mock function for the type Service func (_mock *Service) DeleteReportTemplate(ctx context.Context, session authn.Session, id string) error { ret := _mock.Called(ctx, session, id) @@ -400,6 +491,152 @@ func (_c *Service_GenerateReport_Call) RunAndReturn(run func(ctx context.Context return _c } +// ListAvailableActions provides a mock function for the type Service +func (_mock *Service) ListAvailableActions(ctx context.Context, session authn.Session) ([]string, error) { + ret := _mock.Called(ctx, session) + + if len(ret) == 0 { + panic("no return value specified for ListAvailableActions") + } + + var r0 []string + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) ([]string, error)); ok { + return returnFunc(ctx, session) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session) []string); ok { + r0 = returnFunc(ctx, session) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session) error); ok { + r1 = returnFunc(ctx, session) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Service_ListAvailableActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAvailableActions' +type Service_ListAvailableActions_Call struct { + *mock.Call +} + +// ListAvailableActions is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +func (_e *Service_Expecter) ListAvailableActions(ctx interface{}, session interface{}) *Service_ListAvailableActions_Call { + return &Service_ListAvailableActions_Call{Call: _e.mock.On("ListAvailableActions", ctx, session)} +} + +func (_c *Service_ListAvailableActions_Call) Run(run func(ctx context.Context, session authn.Session)) *Service_ListAvailableActions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Service_ListAvailableActions_Call) Return(strings []string, err error) *Service_ListAvailableActions_Call { + _c.Call.Return(strings, err) + return _c +} + +func (_c *Service_ListAvailableActions_Call) RunAndReturn(run func(ctx context.Context, session authn.Session) ([]string, error)) *Service_ListAvailableActions_Call { + _c.Call.Return(run) + return _c +} + +// ListEntityMembers provides a mock function for the type Service +func (_mock *Service) ListEntityMembers(ctx context.Context, session authn.Session, entityID string, pq roles.MembersRolePageQuery) (roles.MembersRolePage, error) { + ret := _mock.Called(ctx, session, entityID, pq) + + if len(ret) == 0 { + panic("no return value specified for ListEntityMembers") + } + + var r0 roles.MembersRolePage + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, roles.MembersRolePageQuery) (roles.MembersRolePage, error)); ok { + return returnFunc(ctx, session, entityID, pq) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, roles.MembersRolePageQuery) roles.MembersRolePage); ok { + r0 = returnFunc(ctx, session, entityID, pq) + } else { + r0 = ret.Get(0).(roles.MembersRolePage) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, roles.MembersRolePageQuery) error); ok { + r1 = returnFunc(ctx, session, entityID, pq) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Service_ListEntityMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListEntityMembers' +type Service_ListEntityMembers_Call struct { + *mock.Call +} + +// ListEntityMembers is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - pq roles.MembersRolePageQuery +func (_e *Service_Expecter) ListEntityMembers(ctx interface{}, session interface{}, entityID interface{}, pq interface{}) *Service_ListEntityMembers_Call { + return &Service_ListEntityMembers_Call{Call: _e.mock.On("ListEntityMembers", ctx, session, entityID, pq)} +} + +func (_c *Service_ListEntityMembers_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, pq roles.MembersRolePageQuery)) *Service_ListEntityMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 roles.MembersRolePageQuery + if args[3] != nil { + arg3 = args[3].(roles.MembersRolePageQuery) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *Service_ListEntityMembers_Call) Return(membersRolePage roles.MembersRolePage, err error) *Service_ListEntityMembers_Call { + _c.Call.Return(membersRolePage, err) + return _c +} + +func (_c *Service_ListEntityMembers_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, pq roles.MembersRolePageQuery) (roles.MembersRolePage, error)) *Service_ListEntityMembers_Call { + _c.Call.Return(run) + return _c +} + // ListReportsConfig provides a mock function for the type Service func (_mock *Service) ListReportsConfig(ctx context.Context, session authn.Session, pm reports.PageMeta) (reports.ReportConfigPage, error) { ret := _mock.Called(ctx, session, pm) @@ -472,6 +709,138 @@ func (_c *Service_ListReportsConfig_Call) RunAndReturn(run func(ctx context.Cont return _c } +// RemoveEntityMembers provides a mock function for the type Service +func (_mock *Service) RemoveEntityMembers(ctx context.Context, session authn.Session, entityID string, members []string) error { + ret := _mock.Called(ctx, session, entityID, members) + + if len(ret) == 0 { + panic("no return value specified for RemoveEntityMembers") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, []string) error); ok { + r0 = returnFunc(ctx, session, entityID, members) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Service_RemoveEntityMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveEntityMembers' +type Service_RemoveEntityMembers_Call struct { + *mock.Call +} + +// RemoveEntityMembers is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - members []string +func (_e *Service_Expecter) RemoveEntityMembers(ctx interface{}, session interface{}, entityID interface{}, members interface{}) *Service_RemoveEntityMembers_Call { + return &Service_RemoveEntityMembers_Call{Call: _e.mock.On("RemoveEntityMembers", ctx, session, entityID, members)} +} + +func (_c *Service_RemoveEntityMembers_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, members []string)) *Service_RemoveEntityMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 []string + if args[3] != nil { + arg3 = args[3].([]string) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *Service_RemoveEntityMembers_Call) Return(err error) *Service_RemoveEntityMembers_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Service_RemoveEntityMembers_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, members []string) error) *Service_RemoveEntityMembers_Call { + _c.Call.Return(run) + return _c +} + +// RemoveMemberFromAllRoles provides a mock function for the type Service +func (_mock *Service) RemoveMemberFromAllRoles(ctx context.Context, session authn.Session, memberID string) error { + ret := _mock.Called(ctx, session, memberID) + + if len(ret) == 0 { + panic("no return value specified for RemoveMemberFromAllRoles") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) error); ok { + r0 = returnFunc(ctx, session, memberID) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Service_RemoveMemberFromAllRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveMemberFromAllRoles' +type Service_RemoveMemberFromAllRoles_Call struct { + *mock.Call +} + +// RemoveMemberFromAllRoles is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - memberID string +func (_e *Service_Expecter) RemoveMemberFromAllRoles(ctx interface{}, session interface{}, memberID interface{}) *Service_RemoveMemberFromAllRoles_Call { + return &Service_RemoveMemberFromAllRoles_Call{Call: _e.mock.On("RemoveMemberFromAllRoles", ctx, session, memberID)} +} + +func (_c *Service_RemoveMemberFromAllRoles_Call) Run(run func(ctx context.Context, session authn.Session, memberID string)) *Service_RemoveMemberFromAllRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Service_RemoveMemberFromAllRoles_Call) Return(err error) *Service_RemoveMemberFromAllRoles_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Service_RemoveMemberFromAllRoles_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, memberID string) error) *Service_RemoveMemberFromAllRoles_Call { + _c.Call.Return(run) + return _c +} + // RemoveReportConfig provides a mock function for the type Service func (_mock *Service) RemoveReportConfig(ctx context.Context, session authn.Session, id string) error { ret := _mock.Called(ctx, session, id) @@ -535,6 +904,1035 @@ func (_c *Service_RemoveReportConfig_Call) RunAndReturn(run func(ctx context.Con return _c } +// RemoveRole provides a mock function for the type Service +func (_mock *Service) RemoveRole(ctx context.Context, session authn.Session, entityID string, roleID string) error { + ret := _mock.Called(ctx, session, entityID, roleID) + + if len(ret) == 0 { + panic("no return value specified for RemoveRole") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) error); ok { + r0 = returnFunc(ctx, session, entityID, roleID) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Service_RemoveRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRole' +type Service_RemoveRole_Call struct { + *mock.Call +} + +// RemoveRole is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleID string +func (_e *Service_Expecter) RemoveRole(ctx interface{}, session interface{}, entityID interface{}, roleID interface{}) *Service_RemoveRole_Call { + return &Service_RemoveRole_Call{Call: _e.mock.On("RemoveRole", ctx, session, entityID, roleID)} +} + +func (_c *Service_RemoveRole_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleID string)) *Service_RemoveRole_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *Service_RemoveRole_Call) Return(err error) *Service_RemoveRole_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Service_RemoveRole_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleID string) error) *Service_RemoveRole_Call { + _c.Call.Return(run) + return _c +} + +// RetrieveAllRoles provides a mock function for the type Service +func (_mock *Service) RetrieveAllRoles(ctx context.Context, session authn.Session, entityID string, limit uint64, offset uint64) (roles.RolePage, error) { + ret := _mock.Called(ctx, session, entityID, limit, offset) + + if len(ret) == 0 { + panic("no return value specified for RetrieveAllRoles") + } + + var r0 roles.RolePage + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, uint64, uint64) (roles.RolePage, error)); ok { + return returnFunc(ctx, session, entityID, limit, offset) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, uint64, uint64) roles.RolePage); ok { + r0 = returnFunc(ctx, session, entityID, limit, offset) + } else { + r0 = ret.Get(0).(roles.RolePage) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, uint64, uint64) error); ok { + r1 = returnFunc(ctx, session, entityID, limit, offset) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Service_RetrieveAllRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveAllRoles' +type Service_RetrieveAllRoles_Call struct { + *mock.Call +} + +// RetrieveAllRoles is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - limit uint64 +// - offset uint64 +func (_e *Service_Expecter) RetrieveAllRoles(ctx interface{}, session interface{}, entityID interface{}, limit interface{}, offset interface{}) *Service_RetrieveAllRoles_Call { + return &Service_RetrieveAllRoles_Call{Call: _e.mock.On("RetrieveAllRoles", ctx, session, entityID, limit, offset)} +} + +func (_c *Service_RetrieveAllRoles_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, limit uint64, offset uint64)) *Service_RetrieveAllRoles_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 uint64 + if args[3] != nil { + arg3 = args[3].(uint64) + } + var arg4 uint64 + if args[4] != nil { + arg4 = args[4].(uint64) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *Service_RetrieveAllRoles_Call) Return(rolePage roles.RolePage, err error) *Service_RetrieveAllRoles_Call { + _c.Call.Return(rolePage, err) + return _c +} + +func (_c *Service_RetrieveAllRoles_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, limit uint64, offset uint64) (roles.RolePage, error)) *Service_RetrieveAllRoles_Call { + _c.Call.Return(run) + return _c +} + +// RetrieveRole provides a mock function for the type Service +func (_mock *Service) RetrieveRole(ctx context.Context, session authn.Session, entityID string, roleID string) (roles.Role, error) { + ret := _mock.Called(ctx, session, entityID, roleID) + + if len(ret) == 0 { + panic("no return value specified for RetrieveRole") + } + + var r0 roles.Role + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) (roles.Role, error)); ok { + return returnFunc(ctx, session, entityID, roleID) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) roles.Role); ok { + r0 = returnFunc(ctx, session, entityID, roleID) + } else { + r0 = ret.Get(0).(roles.Role) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string) error); ok { + r1 = returnFunc(ctx, session, entityID, roleID) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Service_RetrieveRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveRole' +type Service_RetrieveRole_Call struct { + *mock.Call +} + +// RetrieveRole is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleID string +func (_e *Service_Expecter) RetrieveRole(ctx interface{}, session interface{}, entityID interface{}, roleID interface{}) *Service_RetrieveRole_Call { + return &Service_RetrieveRole_Call{Call: _e.mock.On("RetrieveRole", ctx, session, entityID, roleID)} +} + +func (_c *Service_RetrieveRole_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleID string)) *Service_RetrieveRole_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *Service_RetrieveRole_Call) Return(role roles.Role, err error) *Service_RetrieveRole_Call { + _c.Call.Return(role, err) + return _c +} + +func (_c *Service_RetrieveRole_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleID string) (roles.Role, error)) *Service_RetrieveRole_Call { + _c.Call.Return(run) + return _c +} + +// RoleAddActions provides a mock function for the type Service +func (_mock *Service) RoleAddActions(ctx context.Context, session authn.Session, entityID string, roleID string, actions []string) ([]string, error) { + ret := _mock.Called(ctx, session, entityID, roleID, actions) + + if len(ret) == 0 { + panic("no return value specified for RoleAddActions") + } + + var r0 []string + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, []string) ([]string, error)); ok { + return returnFunc(ctx, session, entityID, roleID, actions) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, []string) []string); ok { + r0 = returnFunc(ctx, session, entityID, roleID, actions) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string, []string) error); ok { + r1 = returnFunc(ctx, session, entityID, roleID, actions) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Service_RoleAddActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleAddActions' +type Service_RoleAddActions_Call struct { + *mock.Call +} + +// RoleAddActions is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleID string +// - actions []string +func (_e *Service_Expecter) RoleAddActions(ctx interface{}, session interface{}, entityID interface{}, roleID interface{}, actions interface{}) *Service_RoleAddActions_Call { + return &Service_RoleAddActions_Call{Call: _e.mock.On("RoleAddActions", ctx, session, entityID, roleID, actions)} +} + +func (_c *Service_RoleAddActions_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleID string, actions []string)) *Service_RoleAddActions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 []string + if args[4] != nil { + arg4 = args[4].([]string) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *Service_RoleAddActions_Call) Return(ops []string, err error) *Service_RoleAddActions_Call { + _c.Call.Return(ops, err) + return _c +} + +func (_c *Service_RoleAddActions_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleID string, actions []string) ([]string, error)) *Service_RoleAddActions_Call { + _c.Call.Return(run) + return _c +} + +// RoleAddMembers provides a mock function for the type Service +func (_mock *Service) RoleAddMembers(ctx context.Context, session authn.Session, entityID string, roleID string, members []string) ([]string, error) { + ret := _mock.Called(ctx, session, entityID, roleID, members) + + if len(ret) == 0 { + panic("no return value specified for RoleAddMembers") + } + + var r0 []string + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, []string) ([]string, error)); ok { + return returnFunc(ctx, session, entityID, roleID, members) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, []string) []string); ok { + r0 = returnFunc(ctx, session, entityID, roleID, members) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string, []string) error); ok { + r1 = returnFunc(ctx, session, entityID, roleID, members) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Service_RoleAddMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleAddMembers' +type Service_RoleAddMembers_Call struct { + *mock.Call +} + +// RoleAddMembers is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleID string +// - members []string +func (_e *Service_Expecter) RoleAddMembers(ctx interface{}, session interface{}, entityID interface{}, roleID interface{}, members interface{}) *Service_RoleAddMembers_Call { + return &Service_RoleAddMembers_Call{Call: _e.mock.On("RoleAddMembers", ctx, session, entityID, roleID, members)} +} + +func (_c *Service_RoleAddMembers_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleID string, members []string)) *Service_RoleAddMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 []string + if args[4] != nil { + arg4 = args[4].([]string) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *Service_RoleAddMembers_Call) Return(strings []string, err error) *Service_RoleAddMembers_Call { + _c.Call.Return(strings, err) + return _c +} + +func (_c *Service_RoleAddMembers_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleID string, members []string) ([]string, error)) *Service_RoleAddMembers_Call { + _c.Call.Return(run) + return _c +} + +// RoleCheckActionsExists provides a mock function for the type Service +func (_mock *Service) RoleCheckActionsExists(ctx context.Context, session authn.Session, entityID string, roleID string, actions []string) (bool, error) { + ret := _mock.Called(ctx, session, entityID, roleID, actions) + + if len(ret) == 0 { + panic("no return value specified for RoleCheckActionsExists") + } + + var r0 bool + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, []string) (bool, error)); ok { + return returnFunc(ctx, session, entityID, roleID, actions) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, []string) bool); ok { + r0 = returnFunc(ctx, session, entityID, roleID, actions) + } else { + r0 = ret.Get(0).(bool) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string, []string) error); ok { + r1 = returnFunc(ctx, session, entityID, roleID, actions) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Service_RoleCheckActionsExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleCheckActionsExists' +type Service_RoleCheckActionsExists_Call struct { + *mock.Call +} + +// RoleCheckActionsExists is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleID string +// - actions []string +func (_e *Service_Expecter) RoleCheckActionsExists(ctx interface{}, session interface{}, entityID interface{}, roleID interface{}, actions interface{}) *Service_RoleCheckActionsExists_Call { + return &Service_RoleCheckActionsExists_Call{Call: _e.mock.On("RoleCheckActionsExists", ctx, session, entityID, roleID, actions)} +} + +func (_c *Service_RoleCheckActionsExists_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleID string, actions []string)) *Service_RoleCheckActionsExists_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 []string + if args[4] != nil { + arg4 = args[4].([]string) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *Service_RoleCheckActionsExists_Call) Return(b bool, err error) *Service_RoleCheckActionsExists_Call { + _c.Call.Return(b, err) + return _c +} + +func (_c *Service_RoleCheckActionsExists_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleID string, actions []string) (bool, error)) *Service_RoleCheckActionsExists_Call { + _c.Call.Return(run) + return _c +} + +// RoleCheckMembersExists provides a mock function for the type Service +func (_mock *Service) RoleCheckMembersExists(ctx context.Context, session authn.Session, entityID string, roleID string, members []string) (bool, error) { + ret := _mock.Called(ctx, session, entityID, roleID, members) + + if len(ret) == 0 { + panic("no return value specified for RoleCheckMembersExists") + } + + var r0 bool + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, []string) (bool, error)); ok { + return returnFunc(ctx, session, entityID, roleID, members) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, []string) bool); ok { + r0 = returnFunc(ctx, session, entityID, roleID, members) + } else { + r0 = ret.Get(0).(bool) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string, []string) error); ok { + r1 = returnFunc(ctx, session, entityID, roleID, members) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Service_RoleCheckMembersExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleCheckMembersExists' +type Service_RoleCheckMembersExists_Call struct { + *mock.Call +} + +// RoleCheckMembersExists is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleID string +// - members []string +func (_e *Service_Expecter) RoleCheckMembersExists(ctx interface{}, session interface{}, entityID interface{}, roleID interface{}, members interface{}) *Service_RoleCheckMembersExists_Call { + return &Service_RoleCheckMembersExists_Call{Call: _e.mock.On("RoleCheckMembersExists", ctx, session, entityID, roleID, members)} +} + +func (_c *Service_RoleCheckMembersExists_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleID string, members []string)) *Service_RoleCheckMembersExists_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 []string + if args[4] != nil { + arg4 = args[4].([]string) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *Service_RoleCheckMembersExists_Call) Return(b bool, err error) *Service_RoleCheckMembersExists_Call { + _c.Call.Return(b, err) + return _c +} + +func (_c *Service_RoleCheckMembersExists_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleID string, members []string) (bool, error)) *Service_RoleCheckMembersExists_Call { + _c.Call.Return(run) + return _c +} + +// RoleListActions provides a mock function for the type Service +func (_mock *Service) RoleListActions(ctx context.Context, session authn.Session, entityID string, roleID string) ([]string, error) { + ret := _mock.Called(ctx, session, entityID, roleID) + + if len(ret) == 0 { + panic("no return value specified for RoleListActions") + } + + var r0 []string + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) ([]string, error)); ok { + return returnFunc(ctx, session, entityID, roleID) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) []string); ok { + r0 = returnFunc(ctx, session, entityID, roleID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string) error); ok { + r1 = returnFunc(ctx, session, entityID, roleID) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Service_RoleListActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleListActions' +type Service_RoleListActions_Call struct { + *mock.Call +} + +// RoleListActions is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleID string +func (_e *Service_Expecter) RoleListActions(ctx interface{}, session interface{}, entityID interface{}, roleID interface{}) *Service_RoleListActions_Call { + return &Service_RoleListActions_Call{Call: _e.mock.On("RoleListActions", ctx, session, entityID, roleID)} +} + +func (_c *Service_RoleListActions_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleID string)) *Service_RoleListActions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *Service_RoleListActions_Call) Return(strings []string, err error) *Service_RoleListActions_Call { + _c.Call.Return(strings, err) + return _c +} + +func (_c *Service_RoleListActions_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleID string) ([]string, error)) *Service_RoleListActions_Call { + _c.Call.Return(run) + return _c +} + +// RoleListMembers provides a mock function for the type Service +func (_mock *Service) RoleListMembers(ctx context.Context, session authn.Session, entityID string, roleID string, limit uint64, offset uint64) (roles.MembersPage, error) { + ret := _mock.Called(ctx, session, entityID, roleID, limit, offset) + + if len(ret) == 0 { + panic("no return value specified for RoleListMembers") + } + + var r0 roles.MembersPage + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, uint64, uint64) (roles.MembersPage, error)); ok { + return returnFunc(ctx, session, entityID, roleID, limit, offset) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, uint64, uint64) roles.MembersPage); ok { + r0 = returnFunc(ctx, session, entityID, roleID, limit, offset) + } else { + r0 = ret.Get(0).(roles.MembersPage) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string, uint64, uint64) error); ok { + r1 = returnFunc(ctx, session, entityID, roleID, limit, offset) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Service_RoleListMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleListMembers' +type Service_RoleListMembers_Call struct { + *mock.Call +} + +// RoleListMembers is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleID string +// - limit uint64 +// - offset uint64 +func (_e *Service_Expecter) RoleListMembers(ctx interface{}, session interface{}, entityID interface{}, roleID interface{}, limit interface{}, offset interface{}) *Service_RoleListMembers_Call { + return &Service_RoleListMembers_Call{Call: _e.mock.On("RoleListMembers", ctx, session, entityID, roleID, limit, offset)} +} + +func (_c *Service_RoleListMembers_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleID string, limit uint64, offset uint64)) *Service_RoleListMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 uint64 + if args[4] != nil { + arg4 = args[4].(uint64) + } + var arg5 uint64 + if args[5] != nil { + arg5 = args[5].(uint64) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + ) + }) + return _c +} + +func (_c *Service_RoleListMembers_Call) Return(membersPage roles.MembersPage, err error) *Service_RoleListMembers_Call { + _c.Call.Return(membersPage, err) + return _c +} + +func (_c *Service_RoleListMembers_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleID string, limit uint64, offset uint64) (roles.MembersPage, error)) *Service_RoleListMembers_Call { + _c.Call.Return(run) + return _c +} + +// RoleRemoveActions provides a mock function for the type Service +func (_mock *Service) RoleRemoveActions(ctx context.Context, session authn.Session, entityID string, roleID string, actions []string) error { + ret := _mock.Called(ctx, session, entityID, roleID, actions) + + if len(ret) == 0 { + panic("no return value specified for RoleRemoveActions") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, []string) error); ok { + r0 = returnFunc(ctx, session, entityID, roleID, actions) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Service_RoleRemoveActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleRemoveActions' +type Service_RoleRemoveActions_Call struct { + *mock.Call +} + +// RoleRemoveActions is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleID string +// - actions []string +func (_e *Service_Expecter) RoleRemoveActions(ctx interface{}, session interface{}, entityID interface{}, roleID interface{}, actions interface{}) *Service_RoleRemoveActions_Call { + return &Service_RoleRemoveActions_Call{Call: _e.mock.On("RoleRemoveActions", ctx, session, entityID, roleID, actions)} +} + +func (_c *Service_RoleRemoveActions_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleID string, actions []string)) *Service_RoleRemoveActions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 []string + if args[4] != nil { + arg4 = args[4].([]string) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *Service_RoleRemoveActions_Call) Return(err error) *Service_RoleRemoveActions_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Service_RoleRemoveActions_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleID string, actions []string) error) *Service_RoleRemoveActions_Call { + _c.Call.Return(run) + return _c +} + +// RoleRemoveAllActions provides a mock function for the type Service +func (_mock *Service) RoleRemoveAllActions(ctx context.Context, session authn.Session, entityID string, roleID string) error { + ret := _mock.Called(ctx, session, entityID, roleID) + + if len(ret) == 0 { + panic("no return value specified for RoleRemoveAllActions") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) error); ok { + r0 = returnFunc(ctx, session, entityID, roleID) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Service_RoleRemoveAllActions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleRemoveAllActions' +type Service_RoleRemoveAllActions_Call struct { + *mock.Call +} + +// RoleRemoveAllActions is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleID string +func (_e *Service_Expecter) RoleRemoveAllActions(ctx interface{}, session interface{}, entityID interface{}, roleID interface{}) *Service_RoleRemoveAllActions_Call { + return &Service_RoleRemoveAllActions_Call{Call: _e.mock.On("RoleRemoveAllActions", ctx, session, entityID, roleID)} +} + +func (_c *Service_RoleRemoveAllActions_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleID string)) *Service_RoleRemoveAllActions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *Service_RoleRemoveAllActions_Call) Return(err error) *Service_RoleRemoveAllActions_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Service_RoleRemoveAllActions_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleID string) error) *Service_RoleRemoveAllActions_Call { + _c.Call.Return(run) + return _c +} + +// RoleRemoveAllMembers provides a mock function for the type Service +func (_mock *Service) RoleRemoveAllMembers(ctx context.Context, session authn.Session, entityID string, roleID string) error { + ret := _mock.Called(ctx, session, entityID, roleID) + + if len(ret) == 0 { + panic("no return value specified for RoleRemoveAllMembers") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string) error); ok { + r0 = returnFunc(ctx, session, entityID, roleID) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Service_RoleRemoveAllMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleRemoveAllMembers' +type Service_RoleRemoveAllMembers_Call struct { + *mock.Call +} + +// RoleRemoveAllMembers is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleID string +func (_e *Service_Expecter) RoleRemoveAllMembers(ctx interface{}, session interface{}, entityID interface{}, roleID interface{}) *Service_RoleRemoveAllMembers_Call { + return &Service_RoleRemoveAllMembers_Call{Call: _e.mock.On("RoleRemoveAllMembers", ctx, session, entityID, roleID)} +} + +func (_c *Service_RoleRemoveAllMembers_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleID string)) *Service_RoleRemoveAllMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *Service_RoleRemoveAllMembers_Call) Return(err error) *Service_RoleRemoveAllMembers_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Service_RoleRemoveAllMembers_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleID string) error) *Service_RoleRemoveAllMembers_Call { + _c.Call.Return(run) + return _c +} + +// RoleRemoveMembers provides a mock function for the type Service +func (_mock *Service) RoleRemoveMembers(ctx context.Context, session authn.Session, entityID string, roleID string, members []string) error { + ret := _mock.Called(ctx, session, entityID, roleID, members) + + if len(ret) == 0 { + panic("no return value specified for RoleRemoveMembers") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, []string) error); ok { + r0 = returnFunc(ctx, session, entityID, roleID, members) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// Service_RoleRemoveMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RoleRemoveMembers' +type Service_RoleRemoveMembers_Call struct { + *mock.Call +} + +// RoleRemoveMembers is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleID string +// - members []string +func (_e *Service_Expecter) RoleRemoveMembers(ctx interface{}, session interface{}, entityID interface{}, roleID interface{}, members interface{}) *Service_RoleRemoveMembers_Call { + return &Service_RoleRemoveMembers_Call{Call: _e.mock.On("RoleRemoveMembers", ctx, session, entityID, roleID, members)} +} + +func (_c *Service_RoleRemoveMembers_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleID string, members []string)) *Service_RoleRemoveMembers_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 []string + if args[4] != nil { + arg4 = args[4].([]string) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *Service_RoleRemoveMembers_Call) Return(err error) *Service_RoleRemoveMembers_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Service_RoleRemoveMembers_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleID string, members []string) error) *Service_RoleRemoveMembers_Call { + _c.Call.Return(run) + return _c +} + // StartScheduler provides a mock function for the type Service func (_mock *Service) StartScheduler(ctx context.Context) error { ret := _mock.Called(ctx) @@ -793,9 +2191,93 @@ func (_c *Service_UpdateReportTemplate_Call) RunAndReturn(run func(ctx context.C return _c } +// UpdateRoleName provides a mock function for the type Service +func (_mock *Service) UpdateRoleName(ctx context.Context, session authn.Session, entityID string, roleID string, newRoleName string) (roles.Role, error) { + ret := _mock.Called(ctx, session, entityID, roleID, newRoleName) + + if len(ret) == 0 { + panic("no return value specified for UpdateRoleName") + } + + var r0 roles.Role + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, string) (roles.Role, error)); ok { + return returnFunc(ctx, session, entityID, roleID, newRoleName) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, string, string) roles.Role); ok { + r0 = returnFunc(ctx, session, entityID, roleID, newRoleName) + } else { + r0 = ret.Get(0).(roles.Role) + } + if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, string, string) error); ok { + r1 = returnFunc(ctx, session, entityID, roleID, newRoleName) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// Service_UpdateRoleName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateRoleName' +type Service_UpdateRoleName_Call struct { + *mock.Call +} + +// UpdateRoleName is a helper method to define mock.On call +// - ctx context.Context +// - session authn.Session +// - entityID string +// - roleID string +// - newRoleName string +func (_e *Service_Expecter) UpdateRoleName(ctx interface{}, session interface{}, entityID interface{}, roleID interface{}, newRoleName interface{}) *Service_UpdateRoleName_Call { + return &Service_UpdateRoleName_Call{Call: _e.mock.On("UpdateRoleName", ctx, session, entityID, roleID, newRoleName)} +} + +func (_c *Service_UpdateRoleName_Call) Run(run func(ctx context.Context, session authn.Session, entityID string, roleID string, newRoleName string)) *Service_UpdateRoleName_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 authn.Session + if args[1] != nil { + arg1 = args[1].(authn.Session) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 string + if args[4] != nil { + arg4 = args[4].(string) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *Service_UpdateRoleName_Call) Return(role roles.Role, err error) *Service_UpdateRoleName_Call { + _c.Call.Return(role, err) + return _c +} + +func (_c *Service_UpdateRoleName_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, entityID string, roleID string, newRoleName string) (roles.Role, error)) *Service_UpdateRoleName_Call { + _c.Call.Return(run) + return _c +} + // ViewReportConfig provides a mock function for the type Service -func (_mock *Service) ViewReportConfig(ctx context.Context, session authn.Session, id string) (reports.ReportConfig, error) { - ret := _mock.Called(ctx, session, id) +func (_mock *Service) ViewReportConfig(ctx context.Context, session authn.Session, id string, withRoles bool) (reports.ReportConfig, error) { + ret := _mock.Called(ctx, session, id, withRoles) if len(ret) == 0 { panic("no return value specified for ViewReportConfig") @@ -803,16 +2285,16 @@ func (_mock *Service) ViewReportConfig(ctx context.Context, session authn.Sessio var r0 reports.ReportConfig var r1 error - if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) (reports.ReportConfig, error)); ok { - return returnFunc(ctx, session, id) + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, bool) (reports.ReportConfig, error)); ok { + return returnFunc(ctx, session, id, withRoles) } - if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string) reports.ReportConfig); ok { - r0 = returnFunc(ctx, session, id) + if returnFunc, ok := ret.Get(0).(func(context.Context, authn.Session, string, bool) reports.ReportConfig); ok { + r0 = returnFunc(ctx, session, id, withRoles) } else { r0 = ret.Get(0).(reports.ReportConfig) } - if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string) error); ok { - r1 = returnFunc(ctx, session, id) + if returnFunc, ok := ret.Get(1).(func(context.Context, authn.Session, string, bool) error); ok { + r1 = returnFunc(ctx, session, id, withRoles) } else { r1 = ret.Error(1) } @@ -828,11 +2310,12 @@ type Service_ViewReportConfig_Call struct { // - ctx context.Context // - session authn.Session // - id string -func (_e *Service_Expecter) ViewReportConfig(ctx interface{}, session interface{}, id interface{}) *Service_ViewReportConfig_Call { - return &Service_ViewReportConfig_Call{Call: _e.mock.On("ViewReportConfig", ctx, session, id)} +// - withRoles bool +func (_e *Service_Expecter) ViewReportConfig(ctx interface{}, session interface{}, id interface{}, withRoles interface{}) *Service_ViewReportConfig_Call { + return &Service_ViewReportConfig_Call{Call: _e.mock.On("ViewReportConfig", ctx, session, id, withRoles)} } -func (_c *Service_ViewReportConfig_Call) Run(run func(ctx context.Context, session authn.Session, id string)) *Service_ViewReportConfig_Call { +func (_c *Service_ViewReportConfig_Call) Run(run func(ctx context.Context, session authn.Session, id string, withRoles bool)) *Service_ViewReportConfig_Call { _c.Call.Run(func(args mock.Arguments) { var arg0 context.Context if args[0] != nil { @@ -846,10 +2329,15 @@ func (_c *Service_ViewReportConfig_Call) Run(run func(ctx context.Context, sessi if args[2] != nil { arg2 = args[2].(string) } + var arg3 bool + if args[3] != nil { + arg3 = args[3].(bool) + } run( arg0, arg1, arg2, + arg3, ) }) return _c @@ -860,7 +2348,7 @@ func (_c *Service_ViewReportConfig_Call) Return(reportConfig reports.ReportConfi return _c } -func (_c *Service_ViewReportConfig_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string) (reports.ReportConfig, error)) *Service_ViewReportConfig_Call { +func (_c *Service_ViewReportConfig_Call) RunAndReturn(run func(ctx context.Context, session authn.Session, id string, withRoles bool) (reports.ReportConfig, error)) *Service_ViewReportConfig_Call { _c.Call.Return(run) return _c } diff --git a/reports/operations.go b/reports/operations.go deleted file mode 100644 index de03f8569..000000000 --- a/reports/operations.go +++ /dev/null @@ -1,80 +0,0 @@ -// Copyright (c) Abstract Machines -// SPDX-License-Identifier: Apache-2.0 - -package reports - -import ( - "github.com/absmach/supermq/pkg/errors" - "github.com/absmach/supermq/pkg/permissions" - "github.com/absmach/supermq/pkg/policies" -) - -const EntityType = "reports" - -const ( - OpAddReportConfig = iota - OpViewReportConfig - OpUpdateReportConfig - OpUpdateReportSchedule - OpRemoveReportConfig - OpListReportsConfig - OpEnableReportConfig - OpDisableReportConfig - OpGenerateReport - OpUpdateReportTemplate - OpViewReportTemplate - OpDeleteReportTemplate -) - -const ( - OpAddReportConfigStr = "OpAddReportConfig" - OpViewReportConfigStr = "OpViewReportConfig" - OpUpdateReportConfigStr = "OpUpdateReportConfig" - OpUpdateReportScheduleStr = "OpUpdateReportSchedule" - OpRemoveReportConfigStr = "OpRemoveReportConfig" - OpListReportsConfigStr = "OpListReportsConfig" - OpEnableReportConfigStr = "OpEnableReportConfig" - OpDisableReportConfigStr = "OpDisableReportConfig" - OpGenerateReportStr = "OpGenerateReport" - OpUpdateReportTemplateStr = "OpUpdateReportTemplate" - OpViewReportTemplateStr = "OpViewReportTemplate" - OpDeleteReportTemplateStr = "OpDeleteReportTemplate" -) - -func GetPermission(op permissions.Operation) (string, error) { - if op < OpAddReportConfig || op > OpDeleteReportTemplate { - return "", errors.New("invalid operation") - } - return policies.MembershipPermission, nil -} - -func OperationName(op permissions.Operation) string { - switch op { - case OpAddReportConfig: - return OpAddReportConfigStr - case OpViewReportConfig: - return OpViewReportConfigStr - case OpUpdateReportConfig: - return OpUpdateReportConfigStr - case OpUpdateReportSchedule: - return OpUpdateReportScheduleStr - case OpRemoveReportConfig: - return OpRemoveReportConfigStr - case OpListReportsConfig: - return OpListReportsConfigStr - case OpEnableReportConfig: - return OpEnableReportConfigStr - case OpDisableReportConfig: - return OpDisableReportConfigStr - case OpGenerateReport: - return OpGenerateReportStr - case OpUpdateReportTemplate: - return OpUpdateReportTemplateStr - case OpViewReportTemplate: - return OpViewReportTemplateStr - case OpDeleteReportTemplate: - return OpDeleteReportTemplateStr - default: - return "unknown" - } -} diff --git a/reports/operations/operations.go b/reports/operations/operations.go new file mode 100644 index 000000000..69cd5934a --- /dev/null +++ b/reports/operations/operations.go @@ -0,0 +1,77 @@ +// Copyright (c) Abstract Machines +// SPDX-License-Identifier: Apache-2.0 + +package operations + +import "github.com/absmach/supermq/pkg/permissions" + +const EntityType = "report" + +// Report Operations. +const ( + OpAddReportConfig permissions.Operation = iota + OpViewReportConfig + OpUpdateReportConfig + OpUpdateReportSchedule + OpRemoveReportConfig + OpListReportsConfig + OpEnableReportConfig + OpDisableReportConfig + OpGenerateReport + OpUpdateReportTemplate + OpViewReportTemplate + OpDeleteReportTemplate +) + +func OperationDetails() map[permissions.Operation]permissions.OperationDetails { + return map[permissions.Operation]permissions.OperationDetails{ + OpAddReportConfig: { + Name: "add", + PermissionRequired: true, + }, + OpViewReportConfig: { + Name: "view", + PermissionRequired: true, + }, + OpUpdateReportConfig: { + Name: "update", + PermissionRequired: true, + }, + OpUpdateReportSchedule: { + Name: "update_schedule", + PermissionRequired: true, + }, + OpRemoveReportConfig: { + Name: "delete", + PermissionRequired: true, + }, + OpListReportsConfig: { + Name: "list", + PermissionRequired: true, + }, + OpEnableReportConfig: { + Name: "enable", + PermissionRequired: true, + }, + OpDisableReportConfig: { + Name: "disable", + PermissionRequired: true, + }, + OpGenerateReport: { + Name: "generate", + PermissionRequired: true, + }, + OpUpdateReportTemplate: { + Name: "update_template", + PermissionRequired: true, + }, + OpViewReportTemplate: { + Name: "view_template", + PermissionRequired: true, + }, + OpDeleteReportTemplate: { + Name: "delete_template", + PermissionRequired: true, + }, + } +} diff --git a/reports/postgres/init.go b/reports/postgres/init.go index 0a4e36b8c..15329caf6 100644 --- a/reports/postgres/init.go +++ b/reports/postgres/init.go @@ -4,12 +4,20 @@ package postgres import ( + dpostgres "github.com/absmach/supermq/domains/postgres" + "github.com/absmach/supermq/pkg/errors" + repoerr "github.com/absmach/supermq/pkg/errors/repository" + rolesPostgres "github.com/absmach/supermq/pkg/roles/repo/postgres" _ "github.com/jackc/pgx/v5/stdlib" // required for SQL access migrate "github.com/rubenv/sql-migrate" ) -func Migration() *migrate.MemoryMigrationSource { - return &migrate.MemoryMigrationSource{ +func Migration() (*migrate.MemoryMigrationSource, error) { + rolesMigration, err := rolesPostgres.Migration(rolesTableNamePrefix, entityTableName, entityIDColumnName) + if err != nil { + return &migrate.MemoryMigrationSource{}, errors.Wrap(repoerr.ErrRoleMigration, err) + } + reportsMigration := &migrate.MemoryMigrationSource{ Migrations: []*migrate.Migration{ { Id: "reports_01", @@ -48,4 +56,14 @@ func Migration() *migrate.MemoryMigrationSource { }, }, } + + reportsMigration.Migrations = append(reportsMigration.Migrations, rolesMigration.Migrations...) + + domainsMigration, err := dpostgres.Migration() + if err != nil { + return &migrate.MemoryMigrationSource{}, errors.Wrap(repoerr.ErrRoleMigration, err) + } + reportsMigration.Migrations = append(reportsMigration.Migrations, domainsMigration.Migrations...) + + return reportsMigration, nil } diff --git a/reports/postgres/reports.go b/reports/postgres/reports.go index 98c53cbd4..53c90c34f 100644 --- a/reports/postgres/reports.go +++ b/reports/postgres/reports.go @@ -11,6 +11,7 @@ import ( "github.com/absmach/magistrala/pkg/schedule" "github.com/absmach/magistrala/reports" "github.com/absmach/supermq/pkg/errors" + "github.com/absmach/supermq/pkg/roles" ) // dbReport represents the database structure for a Report. @@ -32,6 +33,8 @@ type dbReport struct { Metrics []byte `db:"metrics"` Email []byte `db:"email"` ReportTemplate reports.ReportTemplate `db:"report_template"` + MemberID string `db:"member_id,omitempty"` + Roles json.RawMessage `db:"roles,omitempty"` } func reportToDb(r reports.ReportConfig) (dbReport, error) { @@ -113,6 +116,13 @@ func dbToReport(dto dbReport) (reports.ReportConfig, error) { } } + var roles []roles.MemberRoleActions + if dto.Roles != nil { + if err := json.Unmarshal(dto.Roles, &roles); err != nil { + return reports.ReportConfig{}, errors.Wrap(errors.ErrMalformedEntity, err) + } + } + rpt := reports.ReportConfig{ ID: dto.ID, Name: dto.Name, @@ -133,6 +143,7 @@ func dbToReport(dto dbReport) (reports.ReportConfig, error) { UpdatedAt: dto.UpdatedAt, UpdatedBy: dto.UpdatedBy, ReportTemplate: dto.ReportTemplate, + Roles: roles, } return rpt, nil diff --git a/reports/postgres/repository.go b/reports/postgres/repository.go index 2ec7dbad1..0a5b2fc2c 100644 --- a/reports/postgres/repository.go +++ b/reports/postgres/repository.go @@ -10,25 +10,36 @@ import ( "strings" "time" + mgPolicies "github.com/absmach/magistrala/pkg/policies" "github.com/absmach/magistrala/reports" api "github.com/absmach/supermq/api/http" "github.com/absmach/supermq/pkg/errors" repoerr "github.com/absmach/supermq/pkg/errors/repository" "github.com/absmach/supermq/pkg/postgres" + rolesPostgres "github.com/absmach/supermq/pkg/roles/repo/postgres" +) + +const ( + rolesTableNamePrefix = "reports" + entityTableName = "report_config" + entityIDColumnName = "id" ) type PostgresRepository struct { DB postgres.Database eh errors.Handler + rolesPostgres.Repository } func NewRepository(db postgres.Database) reports.Repository { + rolesRepo := rolesPostgres.NewRepository(db, mgPolicies.ReportsType, rolesTableNamePrefix, entityTableName, entityIDColumnName) errHandlerOptions := []errors.HandlerOption{ postgres.WithDuplicateErrors(NewDuplicateErrors()), } return &PostgresRepository{ - DB: db, - eh: postgres.NewErrorHandler(errHandlerOptions...), + DB: db, + eh: postgres.NewErrorHandler(errHandlerOptions...), + Repository: rolesRepo, } } @@ -92,6 +103,155 @@ func (repo *PostgresRepository) ViewReportConfig(ctx context.Context, id string) return rpt, nil } +func (repo *PostgresRepository) RetrieveByIDWithRoles(ctx context.Context, id, memberID string) (reports.ReportConfig, error) { + query := ` + WITH selected_report AS ( + SELECT + r.id, + r.domain_id + FROM + report_config r + WHERE + r.id = :id + LIMIT 1 + ), + selected_report_roles AS ( + SELECT + rr.entity_id AS report_id, + rrm.member_id AS member_id, + rr.id AS role_id, + rr."name" AS role_name, + jsonb_agg(DISTINCT rra."action") AS actions, + 'direct' AS access_type, + '' AS access_provider_id + FROM + reports_roles rr + JOIN + reports_role_members rrm ON rr.id = rrm.role_id + JOIN + reports_role_actions rra ON rr.id = rra.role_id + JOIN + selected_report sr ON sr.id = rr.entity_id + AND rrm.member_id = :member_id + GROUP BY + rr.entity_id, rr.id, rr.name, rrm.member_id + ), + selected_domain_roles AS ( + SELECT + sr.id AS report_id, + drm.member_id AS member_id, + dr.id AS role_id, + dr."name" AS role_name, + jsonb_agg(DISTINCT all_actions."action") AS actions, + 'domain' AS access_type, + dr.entity_id AS access_provider_id + FROM + domains d + JOIN + selected_report sr ON sr.domain_id = d.id + JOIN + domains_roles dr ON dr.entity_id = d.id + JOIN + domains_role_members drm ON dr.id = drm.role_id + JOIN + domains_role_actions dra ON dr.id = dra.role_id + JOIN + domains_role_actions all_actions ON dr.id = all_actions.role_id + WHERE + drm.member_id = :member_id + AND dra."action" LIKE 'report%' + GROUP BY + sr.id, dr.entity_id, dr.id, dr."name", drm.member_id + ), + all_roles AS ( + SELECT + srr.report_id, + srr.member_id, + srr.role_id, + srr.role_name, + srr.actions, + srr.access_type, + srr.access_provider_id + FROM + selected_report_roles srr + UNION + SELECT + sdr.report_id, + sdr.member_id, + sdr.role_id, + sdr.role_name, + sdr.actions, + sdr.access_type, + sdr.access_provider_id + FROM + selected_domain_roles sdr + ), + final_roles AS ( + SELECT + ar.report_id, + ar.member_id, + jsonb_agg( + jsonb_build_object( + 'role_id', ar.role_id, + 'role_name', ar.role_name, + 'actions', ar.actions, + 'access_type', ar.access_type, + 'access_provider_id', ar.access_provider_id + ) + ) AS roles + FROM all_roles ar + GROUP BY + ar.report_id, ar.member_id + ) + SELECT + r2.id, + r2."name", + r2.description, + r2.domain_id, + r2.status, + r2.created_at, + r2.created_by, + r2.updated_at, + r2.updated_by, + r2.due, + r2.recurring, + r2.recurring_period, + r2.start_datetime, + r2.config, + r2.email, + r2.metrics, + r2.report_template, + fr.member_id, + fr.roles + FROM report_config r2 + JOIN final_roles fr ON fr.report_id = r2.id + ` + parameters := map[string]any{ + "id": id, + "member_id": memberID, + } + row, err := repo.DB.NamedQueryContext(ctx, query, parameters) + if err != nil { + return reports.ReportConfig{}, errors.Wrap(repoerr.ErrViewEntity, err) + } + defer row.Close() + + dbreport := dbReport{} + if !row.Next() { + return reports.ReportConfig{}, repoerr.ErrNotFound + } + + if err := row.StructScan(&dbreport); err != nil { + return reports.ReportConfig{}, errors.Wrap(repoerr.ErrViewEntity, err) + } + + cfg, err := dbToReport(dbreport) + if err != nil { + return reports.ReportConfig{}, errors.Wrap(repoerr.ErrViewEntity, err) + } + return cfg, nil +} + func (repo *PostgresRepository) UpdateReportConfigStatus(ctx context.Context, cfg reports.ReportConfig) (reports.ReportConfig, error) { q := `UPDATE report_config SET status = :status, updated_at = :updated_at, updated_by = :updated_by WHERE id = :id diff --git a/reports/postgres/setup_test.go b/reports/postgres/setup_test.go index c8a1b7c47..cac18351d 100644 --- a/reports/postgres/setup_test.go +++ b/reports/postgres/setup_test.go @@ -74,7 +74,11 @@ func TestMain(m *testing.M) { SSLRootCert: "", } - if db, err = postgres.Setup(dbConfig, *rpostgres.Migration()); err != nil { + migration, err := rpostgres.Migration() + if err != nil { + log.Fatalf("Could not get migration: %s", err) + } + if db, err = postgres.Setup(dbConfig, *migration); err != nil { log.Fatalf("Could not setup test DB connection: %s", err) } diff --git a/reports/reports.go b/reports/reports.go index b76a980e3..495f55365 100644 --- a/reports/reports.go +++ b/reports/reports.go @@ -15,6 +15,7 @@ import ( "github.com/absmach/magistrala/pkg/schedule" "github.com/absmach/supermq/pkg/authn" "github.com/absmach/supermq/pkg/errors" + "github.com/absmach/supermq/pkg/roles" "github.com/absmach/supermq/pkg/transformers/senml" ) @@ -152,20 +153,21 @@ func (rm ReqMetric) Validate() error { } type ReportConfig struct { - ID string `json:"id"` - Name string `json:"name"` - Description string `json:"description"` - DomainID string `json:"domain_id"` - Schedule schedule.Schedule `json:"schedule,omitempty"` - Config *MetricConfig `json:"config,omitempty"` - Email *EmailSetting `json:"email,omitempty"` - Metrics []ReqMetric `json:"metrics,omitempty"` - ReportTemplate ReportTemplate `json:"report_template,omitempty"` - Status Status `json:"status"` - CreatedAt time.Time `json:"created_at"` - CreatedBy string `json:"created_by,omitempty"` - UpdatedAt time.Time `json:"updated_at"` - UpdatedBy string `json:"updated_by,omitempty"` + ID string `json:"id"` + Name string `json:"name"` + Description string `json:"description"` + DomainID string `json:"domain_id"` + Schedule schedule.Schedule `json:"schedule,omitempty"` + Config *MetricConfig `json:"config,omitempty"` + Email *EmailSetting `json:"email,omitempty"` + Metrics []ReqMetric `json:"metrics,omitempty"` + ReportTemplate ReportTemplate `json:"report_template,omitempty"` + Status Status `json:"status"` + CreatedAt time.Time `json:"created_at"` + CreatedBy string `json:"created_by,omitempty"` + UpdatedAt time.Time `json:"updated_at"` + UpdatedBy string `json:"updated_by,omitempty"` + Roles []roles.MemberRoleActions `json:"roles,omitempty"` } type ReportConfigPage struct { @@ -398,6 +400,7 @@ type PageMeta struct { type Repository interface { AddReportConfig(ctx context.Context, cfg ReportConfig) (ReportConfig, error) ViewReportConfig(ctx context.Context, id string) (ReportConfig, error) + RetrieveByIDWithRoles(ctx context.Context, id, memberID string) (ReportConfig, error) UpdateReportConfig(ctx context.Context, cfg ReportConfig) (ReportConfig, error) UpdateReportSchedule(ctx context.Context, cfg ReportConfig) (ReportConfig, error) RemoveReportConfig(ctx context.Context, id string) error @@ -408,11 +411,12 @@ type Repository interface { UpdateReportTemplate(ctx context.Context, domainID, reportID string, template ReportTemplate) error ViewReportTemplate(ctx context.Context, domainID, reportID string) (ReportTemplate, error) DeleteReportTemplate(ctx context.Context, domainID, reportID string) error + roles.Repository } type Service interface { AddReportConfig(ctx context.Context, session authn.Session, cfg ReportConfig) (ReportConfig, error) - ViewReportConfig(ctx context.Context, session authn.Session, id string) (ReportConfig, error) + ViewReportConfig(ctx context.Context, session authn.Session, id string, withRoles bool) (ReportConfig, error) UpdateReportConfig(ctx context.Context, session authn.Session, cfg ReportConfig) (ReportConfig, error) UpdateReportSchedule(ctx context.Context, session authn.Session, cfg ReportConfig) (ReportConfig, error) RemoveReportConfig(ctx context.Context, session authn.Session, id string) error @@ -426,4 +430,5 @@ type Service interface { GenerateReport(ctx context.Context, session authn.Session, config ReportConfig, action ReportAction) (ReportPage, error) StartScheduler(ctx context.Context) error + roles.RoleManager } diff --git a/reports/service.go b/reports/service.go index fdba0a32e..f1667c277 100644 --- a/reports/service.go +++ b/reports/service.go @@ -15,10 +15,13 @@ import ( pkglog "github.com/absmach/magistrala/pkg/logger" "github.com/absmach/magistrala/pkg/reltime" "github.com/absmach/magistrala/pkg/ticker" + "github.com/absmach/magistrala/reports/operations" "github.com/absmach/supermq" "github.com/absmach/supermq/pkg/authn" "github.com/absmach/supermq/pkg/errors" svcerr "github.com/absmach/supermq/pkg/errors/service" + "github.com/absmach/supermq/pkg/policies" + "github.com/absmach/supermq/pkg/roles" "github.com/absmach/supermq/pkg/transformers/senml" ) @@ -33,22 +36,28 @@ type report struct { readers grpcReadersV1.ReadersServiceClient defaultTemplate ReportTemplate converterURL string + roles.ProvisionManageService } -func NewService(repo Repository, runInfo chan pkglog.RunInfo, idp supermq.IDProvider, tck ticker.Ticker, emailer emailer.Emailer, readers grpcReadersV1.ReadersServiceClient, template ReportTemplate, converterURL string) Service { - return &report{ - repo: repo, - idp: idp, - runInfo: runInfo, - email: emailer, - ticker: tck, - readers: readers, - defaultTemplate: template, - converterURL: converterURL, +func NewService(repo Repository, runInfo chan pkglog.RunInfo, policy policies.Service, idp supermq.IDProvider, tck ticker.Ticker, emailer emailer.Emailer, readers grpcReadersV1.ReadersServiceClient, template ReportTemplate, converterURL string, availableActions []roles.Action, builtInRoles map[roles.BuiltInRoleName][]roles.Action) (Service, error) { + rpms, err := roles.NewProvisionManageService(operations.EntityType, repo, policy, idp, availableActions, builtInRoles) + if err != nil { + return nil, err } + return &report{ + repo: repo, + idp: idp, + runInfo: runInfo, + email: emailer, + ticker: tck, + readers: readers, + defaultTemplate: template, + converterURL: converterURL, + ProvisionManageService: rpms, + }, nil } -func (r *report) AddReportConfig(ctx context.Context, session authn.Session, cfg ReportConfig) (ReportConfig, error) { +func (r *report) AddReportConfig(ctx context.Context, session authn.Session, cfg ReportConfig) (retCfg ReportConfig, retErr error) { id, err := r.idp.ID() if err != nil { return ReportConfig{}, err @@ -71,11 +80,45 @@ func (r *report) AddReportConfig(ctx context.Context, session authn.Session, cfg return ReportConfig{}, errors.Wrap(svcerr.ErrCreateEntity, err) } + defer func() { + if retErr != nil { + if errRollBack := r.repo.RemoveReportConfig(ctx, reportConfig.ID); errRollBack != nil { + retErr = errors.Wrap(retErr, errors.Wrap(svcerr.ErrRollbackRepo, errRollBack)) + } + } + }() + + newBuiltInRoleMembers := map[roles.BuiltInRoleName][]roles.Member{ + BuiltInRoleAdmin: {roles.Member(session.UserID)}, + } + + optionalPolicies := []policies.Policy{ + { + SubjectType: policies.DomainType, + Subject: session.DomainID, + Relation: policies.DomainRelation, + ObjectType: operations.EntityType, + Object: reportConfig.ID, + }, + } + + _, err = r.AddNewEntitiesRoles(ctx, session.DomainID, session.UserID, []string{reportConfig.ID}, optionalPolicies, newBuiltInRoleMembers) + if err != nil { + return ReportConfig{}, errors.Wrap(svcerr.ErrAddPolicies, err) + } + return reportConfig, nil } -func (r *report) ViewReportConfig(ctx context.Context, session authn.Session, id string) (ReportConfig, error) { - cfg, err := r.repo.ViewReportConfig(ctx, id) +func (r *report) ViewReportConfig(ctx context.Context, session authn.Session, id string, withRoles bool) (ReportConfig, error) { + var cfg ReportConfig + var err error + switch withRoles { + case true: + cfg, err = r.repo.RetrieveByIDWithRoles(ctx, id, session.UserID) + default: + cfg, err = r.repo.ViewReportConfig(ctx, id) + } if err != nil { return ReportConfig{}, errors.Wrap(svcerr.ErrViewEntity, err) } diff --git a/reports/service_test.go b/reports/service_test.go index 17b373a84..6968a235a 100644 --- a/reports/service_test.go +++ b/reports/service_test.go @@ -22,6 +22,8 @@ import ( "github.com/absmach/supermq/pkg/errors" repoerr "github.com/absmach/supermq/pkg/errors/repository" svcerr "github.com/absmach/supermq/pkg/errors/service" + policymocks "github.com/absmach/supermq/pkg/policies/mocks" + "github.com/absmach/supermq/pkg/roles" "github.com/absmach/supermq/pkg/uuid" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/mock" @@ -52,24 +54,39 @@ var ( } ) -func newService(runInfo chan pkglog.RunInfo) (reports.Service, *mocks.Repository, *tmocks.Ticker) { +func newService(t *testing.T, runInfo chan pkglog.RunInfo) (reports.Service, *mocks.Repository, *tmocks.Ticker, *policymocks.Service) { repo := new(mocks.Repository) mockTicker := new(tmocks.Ticker) idProvider := uuid.NewMock() readersSvc := new(readmocks.ReadersServiceClient) e := new(emocks.Emailer) - return reports.NewService(repo, runInfo, idProvider, mockTicker, e, readersSvc, template, ""), repo, mockTicker + policy := new(policymocks.Service) + + availableActions := []roles.Action{} + builtInRoles := map[roles.BuiltInRoleName][]roles.Action{ + "admin": availableActions, + } + + svc, err := reports.NewService(repo, runInfo, policy, idProvider, mockTicker, e, readersSvc, template, "", availableActions, builtInRoles) + if err != nil { + t.Fatalf("Failed to create service: %v", err) + } + return svc, repo, mockTicker, policy } func TestAddReportConfig(t *testing.T) { - svc, repo, _ := newService(make(chan pkglog.RunInfo)) + svc, repo, _, policies := newService(t, make(chan pkglog.RunInfo)) cases := []struct { - desc string - session authn.Session - cfg reports.ReportConfig - res reports.ReportConfig - err error + desc string + session authn.Session + cfg reports.ReportConfig + res reports.ReportConfig + err error + addPoliciesErr error + deletePolicies error + addRoleErr error + deleteErr error }{ { desc: "Add report config successfully", @@ -81,8 +98,11 @@ func TestAddReportConfig(t *testing.T) { Name: reportName, Schedule: schedule, }, - res: rptConfig, - err: nil, + res: rptConfig, + err: nil, + addPoliciesErr: nil, + addRoleErr: nil, + deleteErr: nil, }, { desc: "Add report config with failed repo", @@ -94,13 +114,79 @@ func TestAddReportConfig(t *testing.T) { Name: reportName, Schedule: schedule, }, - err: repoerr.ErrCreateEntity, + err: repoerr.ErrCreateEntity, + addPoliciesErr: nil, + deletePolicies: nil, + addRoleErr: nil, + deleteErr: nil, + }, + { + desc: "Add report config with failed to add policies", + session: authn.Session{ + UserID: userID, + DomainID: domainID, + }, + cfg: reports.ReportConfig{ + Name: reportName, + Schedule: schedule, + }, + res: rptConfig, + addPoliciesErr: svcerr.ErrAuthorization, + err: svcerr.ErrAddPolicies, + }, + { + desc: "Add report config with failed to add policies and failed rollback", + session: authn.Session{ + UserID: userID, + DomainID: domainID, + }, + cfg: reports.ReportConfig{ + Name: reportName, + Schedule: schedule, + }, + res: rptConfig, + addPoliciesErr: svcerr.ErrAuthorization, + deleteErr: svcerr.ErrRemoveEntity, + err: svcerr.ErrRollbackRepo, + }, + { + desc: "Add report config with failed to add roles", + session: authn.Session{ + UserID: userID, + DomainID: domainID, + }, + cfg: reports.ReportConfig{ + Name: reportName, + Schedule: schedule, + }, + res: rptConfig, + addRoleErr: svcerr.ErrCreateEntity, + err: svcerr.ErrAddPolicies, + }, + { + desc: "Add report config with failed to add roles and failed to delete policies", + session: authn.Session{ + UserID: userID, + DomainID: domainID, + }, + cfg: reports.ReportConfig{ + Name: reportName, + Schedule: schedule, + }, + res: rptConfig, + addRoleErr: svcerr.ErrCreateEntity, + deletePolicies: svcerr.ErrRemoveEntity, + err: svcerr.ErrRemoveEntity, }, } for _, tc := range cases { t.Run(tc.desc, func(t *testing.T) { repoCall := repo.On("AddReportConfig", mock.Anything, mock.Anything).Return(tc.res, tc.err) + policyCall := policies.On("AddPolicies", context.Background(), mock.Anything).Return(tc.addPoliciesErr) + policyCall2 := policies.On("DeletePolicies", context.Background(), mock.Anything).Return(tc.deletePolicies).Maybe() + repoCall1 := repo.On("AddRoles", context.Background(), mock.Anything).Return([]roles.RoleProvision{}, tc.addRoleErr) + repoCall2 := repo.On("Remove", context.Background(), mock.Anything).Return(tc.deleteErr).Maybe() res, err := svc.AddReportConfig(context.Background(), tc.session, tc.cfg) assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err)) if err == nil { @@ -108,13 +194,17 @@ func TestAddReportConfig(t *testing.T) { assert.Equal(t, tc.cfg.Name, res.Name) assert.Equal(t, tc.cfg.Schedule, res.Schedule) } - defer repoCall.Unset() + policyCall.Unset() + policyCall2.Unset() + repoCall.Unset() + repoCall1.Unset() + repoCall2.Unset() }) } } func TestViewReportConfig(t *testing.T) { - svc, repo, _ := newService(make(chan pkglog.RunInfo)) + svc, repo, _, _ := newService(t, make(chan pkglog.RunInfo)) cases := []struct { desc string @@ -147,7 +237,7 @@ func TestViewReportConfig(t *testing.T) { for _, tc := range cases { t.Run(tc.desc, func(t *testing.T) { repoCall := repo.On("ViewReportConfig", mock.Anything, mock.Anything).Return(tc.res, tc.err) - res, err := svc.ViewReportConfig(context.Background(), tc.session, tc.id) + res, err := svc.ViewReportConfig(context.Background(), tc.session, tc.id, false) assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err)) if err == nil { assert.Equal(t, tc.res, res) @@ -158,7 +248,7 @@ func TestViewReportConfig(t *testing.T) { } func TestUpdateReportConfig(t *testing.T) { - svc, repo, _ := newService(make(chan pkglog.RunInfo)) + svc, repo, _, _ := newService(t, make(chan pkglog.RunInfo)) newName := namegen.Generate() now := time.Now().Add(time.Hour) @@ -220,7 +310,7 @@ func TestUpdateReportConfig(t *testing.T) { } func TestListReportsConfig(t *testing.T) { - svc, repo, _ := newService(make(chan pkglog.RunInfo)) + svc, repo, _, _ := newService(t, make(chan pkglog.RunInfo)) numConfigs := 50 now := time.Now().Add(time.Hour) var configs []reports.ReportConfig @@ -325,13 +415,14 @@ func TestListReportsConfig(t *testing.T) { } func TestRemoveReportConfig(t *testing.T) { - svc, repo, _ := newService(make(chan pkglog.RunInfo)) + svc, repo, _, policies := newService(t, make(chan pkglog.RunInfo)) cases := []struct { - desc string - session authn.Session - id string - err error + desc string + session authn.Session + id string + err error + deletePoliciesErr error }{ { desc: "remove report config successfully", @@ -339,8 +430,9 @@ func TestRemoveReportConfig(t *testing.T) { UserID: userID, DomainID: domainID, }, - id: rptConfig.ID, - err: nil, + id: rptConfig.ID, + err: nil, + deletePoliciesErr: nil, }, { desc: "remove report config with failed repo", @@ -348,24 +440,27 @@ func TestRemoveReportConfig(t *testing.T) { UserID: userID, DomainID: domainID, }, - id: rptConfig.ID, - err: svcerr.ErrRemoveEntity, + id: rptConfig.ID, + err: svcerr.ErrRemoveEntity, + deletePoliciesErr: nil, }, } for _, tc := range cases { t.Run(tc.desc, func(t *testing.T) { repoCall := repo.On("RemoveReportConfig", mock.Anything, mock.Anything).Return(tc.err) + policyCall := policies.On("DeletePolicies", context.Background(), mock.Anything).Return(tc.deletePoliciesErr) err := svc.RemoveReportConfig(context.Background(), tc.session, tc.id) assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err)) - defer repoCall.Unset() + policyCall.Unset() + repoCall.Unset() }) } } func TestEnableReportConfig(t *testing.T) { - svc, repo, _ := newService(make(chan pkglog.RunInfo)) + svc, repo, _, _ := newService(t, make(chan pkglog.RunInfo)) cases := []struct { desc string @@ -413,7 +508,7 @@ func TestEnableReportConfig(t *testing.T) { } func TestDisableReportConfig(t *testing.T) { - svc, repo, _ := newService(make(chan pkglog.RunInfo)) + svc, repo, _, _ := newService(t, make(chan pkglog.RunInfo)) cases := []struct { desc string @@ -469,7 +564,8 @@ func TestDisableReportConfig(t *testing.T) { } func TestGenerateInstantEmailReport(t *testing.T) { - svc, _, _ := newService(make(chan pkglog.RunInfo)) + // nolint:dogsled + svc, _, _, _ := newService(t, make(chan pkglog.RunInfo)) validEmailConfig := reports.EmailSetting{ To: []string{"test@example.com"},