b9262b5150
Introduce a hierarchical risk assessment model with six entity types: - Risk Assessment: top-level container scoped to an organization - Risk Assessment Scope: sub-container for scoping threat modeling exercises within an assessment - Risk Assessment Node: DFD elements typed as ENTITY, BOUNDARY, ASSET, or DATA within a scope - Risk Assessment Process: directed data flows between two nodes - Risk Assessment Threat: descriptive threats attached to a process with a free-text category (e.g. Confidentiality, Integrity) - Risk Scenario: thin join linking a threat to a risk from the register, carrying only a name and description Risk scoring (likelihood, impact, treatment) remains on the existing Risk entity. Threats are purely descriptive. Risk Scenarios connect the threat model to the risk register without duplicating scores. Backend: migration with PG enum for node types, coredata structs, service layer with full CRUD and validation, GraphQL schema with 18 mutations and paginated connections, authorization actions and policies, and base_resolvers.go Node dispatch for all entity types. Frontend: Risk Assessments list page with create dialog, detail page showing scopes as cards with nodes/processes/threats tables, inline create/edit/delete actions on all entities, and a Scenarios tab on the Risk detail page linking threats to risks. Existing RiskGraph.ts hook file removed in favor of colocated queries in page files. E2E tests cover CRUD for all entity types, RBAC, and tenant isolation. Signed-off-by: Sacha Al Himdani <sacha@getprobo.com>
948 lines
42 KiB
Go
948 lines
42 KiB
Go
package console_v1
|
|
|
|
// This file will be automatically regenerated based on the schema, any resolver
|
|
// implementations
|
|
// will be copied through when generating and any unknown code will be moved to the end.
|
|
// Code generated by github.com/99designs/gqlgen version v0.17.90
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
|
|
"github.com/vikstrous/dataloadgen"
|
|
"go.gearno.de/kit/log"
|
|
"go.probo.inc/probo/pkg/coredata"
|
|
"go.probo.inc/probo/pkg/page"
|
|
"go.probo.inc/probo/pkg/probo"
|
|
"go.probo.inc/probo/pkg/riskmanagement"
|
|
"go.probo.inc/probo/pkg/server/api/console/v1/dataloader"
|
|
"go.probo.inc/probo/pkg/server/api/console/v1/schema"
|
|
"go.probo.inc/probo/pkg/server/api/console/v1/types"
|
|
"go.probo.inc/probo/pkg/server/gqlutils"
|
|
"go.probo.inc/probo/pkg/validator"
|
|
)
|
|
|
|
// CreateRiskAssessment is the resolver for the createRiskAssessment field.
|
|
func (r *mutationResolver) CreateRiskAssessment(ctx context.Context, input types.CreateRiskAssessmentInput) (*types.CreateRiskAssessmentPayload, error) {
|
|
if err := r.authorize(ctx, input.OrganizationID, probo.ActionRiskAssessmentCreate); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.OrganizationID)
|
|
ra, err := r.riskManagement.Create(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.CreateRiskAssessmentRequest{
|
|
OrganizationID: input.OrganizationID,
|
|
Name: input.Name,
|
|
Description: input.Description,
|
|
},
|
|
)
|
|
if err != nil {
|
|
if errors.Is(err, coredata.ErrResourceAlreadyExists) {
|
|
return nil, gqlutils.Conflict(ctx, err)
|
|
}
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot create risk assessment", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.CreateRiskAssessmentPayload{
|
|
RiskAssessmentEdge: types.NewRiskAssessmentConnectionEdge(ra, coredata.RiskAssessmentOrderFieldCreatedAt),
|
|
}, nil
|
|
}
|
|
|
|
// UpdateRiskAssessment is the resolver for the updateRiskAssessment field.
|
|
func (r *mutationResolver) UpdateRiskAssessment(ctx context.Context, input types.UpdateRiskAssessmentInput) (*types.UpdateRiskAssessmentPayload, error) {
|
|
if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentUpdate); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.ID)
|
|
ra, err := r.riskManagement.Update(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.UpdateRiskAssessmentRequest{
|
|
ID: input.ID,
|
|
Name: input.Name,
|
|
Description: gqlutils.UnwrapOmittable(input.Description),
|
|
},
|
|
)
|
|
if err != nil {
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot update risk assessment", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.UpdateRiskAssessmentPayload{RiskAssessment: types.NewRiskAssessment(ra)}, nil
|
|
}
|
|
|
|
// DeleteRiskAssessment is the resolver for the deleteRiskAssessment field.
|
|
func (r *mutationResolver) DeleteRiskAssessment(ctx context.Context, input types.DeleteRiskAssessmentInput) (*types.DeleteRiskAssessmentPayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentID, probo.ActionRiskAssessmentDelete); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentID)
|
|
if err := r.riskManagement.Delete(ctx, scope, input.RiskAssessmentID); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return nil, gqlutils.NotFound(ctx, err)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot delete risk assessment", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.DeleteRiskAssessmentPayload{DeletedRiskAssessmentID: input.RiskAssessmentID}, nil
|
|
}
|
|
|
|
// CreateRiskAssessmentScope is the resolver for the createRiskAssessmentScope field.
|
|
func (r *mutationResolver) CreateRiskAssessmentScope(ctx context.Context, input types.CreateRiskAssessmentScopeInput) (*types.CreateRiskAssessmentScopePayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentID, probo.ActionRiskAssessmentScopeCreate); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentID)
|
|
raScope, err := r.riskManagement.CreateScope(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.CreateRiskAssessmentScopeRequest{
|
|
RiskAssessmentID: input.RiskAssessmentID,
|
|
Name: input.Name,
|
|
},
|
|
)
|
|
if err != nil {
|
|
if errors.Is(err, coredata.ErrResourceAlreadyExists) {
|
|
return nil, gqlutils.Conflict(ctx, err)
|
|
}
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot create risk assessment scope", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.CreateRiskAssessmentScopePayload{
|
|
RiskAssessmentScopeEdge: types.NewRiskAssessmentScopeConnectionEdge(raScope, coredata.RiskAssessmentScopeOrderFieldCreatedAt),
|
|
}, nil
|
|
}
|
|
|
|
// UpdateRiskAssessmentScope is the resolver for the updateRiskAssessmentScope field.
|
|
func (r *mutationResolver) UpdateRiskAssessmentScope(ctx context.Context, input types.UpdateRiskAssessmentScopeInput) (*types.UpdateRiskAssessmentScopePayload, error) {
|
|
if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentScopeUpdate); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.ID)
|
|
raScope, err := r.riskManagement.UpdateScope(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.UpdateRiskAssessmentScopeRequest{
|
|
ID: input.ID,
|
|
Name: input.Name,
|
|
},
|
|
)
|
|
if err != nil {
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot update risk assessment scope", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.UpdateRiskAssessmentScopePayload{RiskAssessmentScope: types.NewRiskAssessmentScope(raScope)}, nil
|
|
}
|
|
|
|
// DeleteRiskAssessmentScope is the resolver for the deleteRiskAssessmentScope field.
|
|
func (r *mutationResolver) DeleteRiskAssessmentScope(ctx context.Context, input types.DeleteRiskAssessmentScopeInput) (*types.DeleteRiskAssessmentScopePayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentScopeDelete); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
|
|
if err := r.riskManagement.DeleteScope(ctx, scope, input.RiskAssessmentScopeID); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return nil, gqlutils.NotFound(ctx, err)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot delete risk assessment scope", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.DeleteRiskAssessmentScopePayload{DeletedRiskAssessmentScopeID: input.RiskAssessmentScopeID}, nil
|
|
}
|
|
|
|
// CreateRiskAssessmentNode is the resolver for the createRiskAssessmentNode field.
|
|
func (r *mutationResolver) CreateRiskAssessmentNode(ctx context.Context, input types.CreateRiskAssessmentNodeInput) (*types.CreateRiskAssessmentNodePayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentNodeCreate); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
|
|
node, err := r.riskManagement.CreateNode(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.CreateRiskAssessmentNodeRequest{
|
|
RiskAssessmentScopeID: input.RiskAssessmentScopeID,
|
|
NodeType: input.NodeType,
|
|
Name: input.Name,
|
|
},
|
|
)
|
|
if err != nil {
|
|
if errors.Is(err, coredata.ErrResourceAlreadyExists) {
|
|
return nil, gqlutils.Conflict(ctx, err)
|
|
}
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot create risk assessment node", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.CreateRiskAssessmentNodePayload{
|
|
RiskAssessmentNodeEdge: &types.RiskAssessmentNodeConnectionEdge{
|
|
Cursor: node.CursorKey(coredata.RiskAssessmentNodeOrderFieldCreatedAt),
|
|
Node: types.NewRiskAssessmentNode(node),
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// UpdateRiskAssessmentNode is the resolver for the updateRiskAssessmentNode field.
|
|
func (r *mutationResolver) UpdateRiskAssessmentNode(ctx context.Context, input types.UpdateRiskAssessmentNodeInput) (*types.UpdateRiskAssessmentNodePayload, error) {
|
|
if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentNodeUpdate); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.ID)
|
|
node, err := r.riskManagement.UpdateNode(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.UpdateRiskAssessmentNodeRequest{
|
|
ID: input.ID,
|
|
NodeType: input.NodeType,
|
|
Name: input.Name,
|
|
},
|
|
)
|
|
if err != nil {
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot update risk assessment node", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.UpdateRiskAssessmentNodePayload{RiskAssessmentNode: types.NewRiskAssessmentNode(node)}, nil
|
|
}
|
|
|
|
// DeleteRiskAssessmentNode is the resolver for the deleteRiskAssessmentNode field.
|
|
func (r *mutationResolver) DeleteRiskAssessmentNode(ctx context.Context, input types.DeleteRiskAssessmentNodeInput) (*types.DeleteRiskAssessmentNodePayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentNodeID, probo.ActionRiskAssessmentNodeDelete); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentNodeID)
|
|
if err := r.riskManagement.DeleteNode(ctx, scope, input.RiskAssessmentNodeID); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return nil, gqlutils.NotFound(ctx, err)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot delete risk assessment node", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.DeleteRiskAssessmentNodePayload{DeletedRiskAssessmentNodeID: input.RiskAssessmentNodeID}, nil
|
|
}
|
|
|
|
// CreateRiskAssessmentProcess is the resolver for the createRiskAssessmentProcess field.
|
|
func (r *mutationResolver) CreateRiskAssessmentProcess(ctx context.Context, input types.CreateRiskAssessmentProcessInput) (*types.CreateRiskAssessmentProcessPayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentProcessCreate); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
|
|
process, err := r.riskManagement.CreateProcess(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.CreateRiskAssessmentProcessRequest{
|
|
RiskAssessmentScopeID: input.RiskAssessmentScopeID,
|
|
SourceNodeID: input.SourceNodeID,
|
|
TargetNodeID: input.TargetNodeID,
|
|
Name: input.Name,
|
|
},
|
|
)
|
|
if err != nil {
|
|
if errors.Is(err, coredata.ErrResourceAlreadyExists) {
|
|
return nil, gqlutils.Conflict(ctx, err)
|
|
}
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot create risk assessment process", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.CreateRiskAssessmentProcessPayload{
|
|
RiskAssessmentProcessEdge: &types.RiskAssessmentProcessConnectionEdge{
|
|
Cursor: process.CursorKey(coredata.RiskAssessmentProcessOrderFieldCreatedAt),
|
|
Node: types.NewRiskAssessmentProcess(process),
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// UpdateRiskAssessmentProcess is the resolver for the updateRiskAssessmentProcess field.
|
|
func (r *mutationResolver) UpdateRiskAssessmentProcess(ctx context.Context, input types.UpdateRiskAssessmentProcessInput) (*types.UpdateRiskAssessmentProcessPayload, error) {
|
|
if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentProcessUpdate); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.ID)
|
|
process, err := r.riskManagement.UpdateProcess(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.UpdateRiskAssessmentProcessRequest{
|
|
ID: input.ID,
|
|
SourceNodeID: input.SourceNodeID,
|
|
TargetNodeID: input.TargetNodeID,
|
|
Name: input.Name,
|
|
},
|
|
)
|
|
if err != nil {
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot update risk assessment process", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.UpdateRiskAssessmentProcessPayload{RiskAssessmentProcess: types.NewRiskAssessmentProcess(process)}, nil
|
|
}
|
|
|
|
// DeleteRiskAssessmentProcess is the resolver for the deleteRiskAssessmentProcess field.
|
|
func (r *mutationResolver) DeleteRiskAssessmentProcess(ctx context.Context, input types.DeleteRiskAssessmentProcessInput) (*types.DeleteRiskAssessmentProcessPayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentProcessID, probo.ActionRiskAssessmentProcessDelete); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentProcessID)
|
|
if err := r.riskManagement.DeleteProcess(ctx, scope, input.RiskAssessmentProcessID); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return nil, gqlutils.NotFound(ctx, err)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot delete risk assessment process", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.DeleteRiskAssessmentProcessPayload{DeletedRiskAssessmentProcessID: input.RiskAssessmentProcessID}, nil
|
|
}
|
|
|
|
// CreateRiskAssessmentThreat is the resolver for the createRiskAssessmentThreat field.
|
|
func (r *mutationResolver) CreateRiskAssessmentThreat(ctx context.Context, input types.CreateRiskAssessmentThreatInput) (*types.CreateRiskAssessmentThreatPayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentThreatCreate); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
|
|
threat, err := r.riskManagement.CreateThreat(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.CreateRiskAssessmentThreatRequest{
|
|
RiskAssessmentScopeID: input.RiskAssessmentScopeID,
|
|
ProcessID: input.ProcessID,
|
|
Name: input.Name,
|
|
Category: input.Category,
|
|
},
|
|
)
|
|
if err != nil {
|
|
if errors.Is(err, coredata.ErrResourceAlreadyExists) {
|
|
return nil, gqlutils.Conflict(ctx, err)
|
|
}
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot create risk threat", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.CreateRiskAssessmentThreatPayload{
|
|
RiskAssessmentThreatEdge: &types.RiskAssessmentThreatConnectionEdge{
|
|
Cursor: threat.CursorKey(coredata.RiskAssessmentThreatOrderFieldCreatedAt),
|
|
Node: types.NewRiskAssessmentThreat(threat),
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// UpdateRiskAssessmentThreat is the resolver for the updateRiskAssessmentThreat field.
|
|
func (r *mutationResolver) UpdateRiskAssessmentThreat(ctx context.Context, input types.UpdateRiskAssessmentThreatInput) (*types.UpdateRiskAssessmentThreatPayload, error) {
|
|
if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentThreatUpdate); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.ID)
|
|
threat, err := r.riskManagement.UpdateThreat(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.UpdateRiskAssessmentThreatRequest{
|
|
ID: input.ID,
|
|
ProcessID: input.ProcessID,
|
|
Name: input.Name,
|
|
Category: input.Category,
|
|
},
|
|
)
|
|
if err != nil {
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot update risk threat", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.UpdateRiskAssessmentThreatPayload{RiskAssessmentThreat: types.NewRiskAssessmentThreat(threat)}, nil
|
|
}
|
|
|
|
// DeleteRiskAssessmentThreat is the resolver for the deleteRiskAssessmentThreat field.
|
|
func (r *mutationResolver) DeleteRiskAssessmentThreat(ctx context.Context, input types.DeleteRiskAssessmentThreatInput) (*types.DeleteRiskAssessmentThreatPayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentThreatID, probo.ActionRiskAssessmentThreatDelete); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentThreatID)
|
|
if err := r.riskManagement.DeleteThreat(ctx, scope, input.RiskAssessmentThreatID); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return nil, gqlutils.NotFound(ctx, err)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot delete risk threat", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.DeleteRiskAssessmentThreatPayload{DeletedRiskAssessmentThreatID: input.RiskAssessmentThreatID}, nil
|
|
}
|
|
|
|
// CreateRiskAssessmentScenario is the resolver for the createRiskAssessmentScenario field.
|
|
func (r *mutationResolver) CreateRiskAssessmentScenario(ctx context.Context, input types.CreateRiskAssessmentScenarioInput) (*types.CreateRiskAssessmentScenarioPayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentScopeID, probo.ActionRiskAssessmentScenarioCreate); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScopeID)
|
|
scenario, err := r.riskManagement.CreateScenario(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.CreateRiskAssessmentScenarioRequest{
|
|
RiskAssessmentScopeID: input.RiskAssessmentScopeID,
|
|
Name: input.Name,
|
|
Description: input.Description,
|
|
},
|
|
)
|
|
if err != nil {
|
|
if errors.Is(err, coredata.ErrResourceAlreadyExists) {
|
|
return nil, gqlutils.Conflict(ctx, err)
|
|
}
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot create risk scenario", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.CreateRiskAssessmentScenarioPayload{
|
|
RiskAssessmentScenarioEdge: &types.RiskAssessmentScenarioConnectionEdge{
|
|
Cursor: scenario.CursorKey(coredata.RiskAssessmentScenarioOrderFieldCreatedAt),
|
|
Node: types.NewRiskAssessmentScenario(scenario),
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// UpdateRiskAssessmentScenario is the resolver for the updateRiskAssessmentScenario field.
|
|
func (r *mutationResolver) UpdateRiskAssessmentScenario(ctx context.Context, input types.UpdateRiskAssessmentScenarioInput) (*types.UpdateRiskAssessmentScenarioPayload, error) {
|
|
if err := r.authorize(ctx, input.ID, probo.ActionRiskAssessmentScenarioUpdate); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.ID)
|
|
scenario, err := r.riskManagement.UpdateScenario(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.UpdateRiskAssessmentScenarioRequest{
|
|
ID: input.ID,
|
|
Name: input.Name,
|
|
Description: gqlutils.UnwrapOmittable(input.Description),
|
|
},
|
|
)
|
|
if err != nil {
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot update risk scenario", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.UpdateRiskAssessmentScenarioPayload{RiskAssessmentScenario: types.NewRiskAssessmentScenario(scenario)}, nil
|
|
}
|
|
|
|
// DeleteRiskAssessmentScenario is the resolver for the deleteRiskAssessmentScenario field.
|
|
func (r *mutationResolver) DeleteRiskAssessmentScenario(ctx context.Context, input types.DeleteRiskAssessmentScenarioInput) (*types.DeleteRiskAssessmentScenarioPayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioDelete); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
|
|
if err := r.riskManagement.DeleteScenario(ctx, scope, input.RiskAssessmentScenarioID); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) {
|
|
return nil, gqlutils.NotFound(ctx, err)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot delete risk scenario", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.DeleteRiskAssessmentScenarioPayload{DeletedRiskAssessmentScenarioID: input.RiskAssessmentScenarioID}, nil
|
|
}
|
|
|
|
// LinkRiskAssessmentScenarioThreat is the resolver for the linkRiskAssessmentScenarioThreat field.
|
|
func (r *mutationResolver) LinkRiskAssessmentScenarioThreat(ctx context.Context, input types.LinkRiskAssessmentScenarioThreatInput) (*types.LinkRiskAssessmentScenarioThreatPayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioThreatLink); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
|
|
if err := r.riskManagement.LinkScenarioThreat(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.LinkRiskAssessmentScenarioThreatRequest{
|
|
RiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
|
|
ThreatID: input.ThreatID,
|
|
},
|
|
); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceAlreadyExists) {
|
|
return nil, gqlutils.Conflict(ctx, err)
|
|
}
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot link risk scenario threat", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.LinkRiskAssessmentScenarioThreatPayload{RiskAssessmentScenario: types.NewRiskAssessmentScenario(scenario)}, nil
|
|
}
|
|
|
|
// UnlinkRiskAssessmentScenarioThreat is the resolver for the unlinkRiskAssessmentScenarioThreat field.
|
|
func (r *mutationResolver) UnlinkRiskAssessmentScenarioThreat(ctx context.Context, input types.UnlinkRiskAssessmentScenarioThreatInput) (*types.UnlinkRiskAssessmentScenarioThreatPayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioThreatUnlink); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
|
|
if err := r.riskManagement.UnlinkScenarioThreat(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.UnlinkRiskAssessmentScenarioThreatRequest{
|
|
RiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
|
|
ThreatID: input.ThreatID,
|
|
},
|
|
); err != nil {
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot unlink risk scenario threat", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.UnlinkRiskAssessmentScenarioThreatPayload{RiskAssessmentScenario: types.NewRiskAssessmentScenario(scenario)}, nil
|
|
}
|
|
|
|
// LinkRiskAssessmentScenarioRisk is the resolver for the linkRiskAssessmentScenarioRisk field.
|
|
func (r *mutationResolver) LinkRiskAssessmentScenarioRisk(ctx context.Context, input types.LinkRiskAssessmentScenarioRiskInput) (*types.LinkRiskAssessmentScenarioRiskPayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioRiskLink); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
|
|
if err := r.riskManagement.LinkScenarioRisk(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.LinkRiskAssessmentScenarioRiskRequest{
|
|
RiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
|
|
RiskID: input.RiskID,
|
|
},
|
|
); err != nil {
|
|
if errors.Is(err, coredata.ErrResourceAlreadyExists) {
|
|
return nil, gqlutils.Conflict(ctx, err)
|
|
}
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot link risk scenario risk", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
s := types.NewRiskAssessmentScenario(scenario)
|
|
return &types.LinkRiskAssessmentScenarioRiskPayload{
|
|
RiskAssessmentScenario: s,
|
|
RiskAssessmentScenarioEdge: &types.RiskAssessmentScenarioConnectionEdge{
|
|
Cursor: scenario.CursorKey(coredata.RiskAssessmentScenarioOrderFieldCreatedAt),
|
|
Node: s,
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
// UnlinkRiskAssessmentScenarioRisk is the resolver for the unlinkRiskAssessmentScenarioRisk field.
|
|
func (r *mutationResolver) UnlinkRiskAssessmentScenarioRisk(ctx context.Context, input types.UnlinkRiskAssessmentScenarioRiskInput) (*types.UnlinkRiskAssessmentScenarioRiskPayload, error) {
|
|
if err := r.authorize(ctx, input.RiskAssessmentScenarioID, probo.ActionRiskAssessmentScenarioRiskUnlink); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(input.RiskAssessmentScenarioID)
|
|
if err := r.riskManagement.UnlinkScenarioRisk(
|
|
ctx,
|
|
scope,
|
|
riskmanagement.UnlinkRiskAssessmentScenarioRiskRequest{
|
|
RiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
|
|
RiskID: input.RiskID,
|
|
},
|
|
); err != nil {
|
|
if validationErrors, ok := errors.AsType[validator.ValidationErrors](err); ok {
|
|
return nil, gqlutils.InvalidValidationErrors(ctx, validationErrors)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot unlink risk scenario risk", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
scenario, err := r.riskManagement.GetScenario(ctx, scope, input.RiskAssessmentScenarioID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot load risk scenario", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &types.UnlinkRiskAssessmentScenarioRiskPayload{
|
|
RiskAssessmentScenario: types.NewRiskAssessmentScenario(scenario),
|
|
DeletedRiskAssessmentScenarioID: input.RiskAssessmentScenarioID,
|
|
}, nil
|
|
}
|
|
|
|
// Organization is the resolver for the organization field.
|
|
func (r *riskAssessmentResolver) Organization(ctx context.Context, obj *types.RiskAssessment) (*types.Organization, error) {
|
|
if err := r.authorize(ctx, obj.ID, probo.ActionOrganizationGet); err != nil {
|
|
return nil, err
|
|
}
|
|
loaders := dataloader.FromContext(ctx)
|
|
organization, err := loaders.Organization.Load(ctx, obj.Organization.ID)
|
|
if err != nil {
|
|
if errors.Is(err, coredata.ErrResourceNotFound) || errors.Is(err, dataloadgen.ErrNotFound) {
|
|
return nil, gqlutils.NotFound(ctx, err)
|
|
}
|
|
r.logger.ErrorCtx(ctx, "cannot get organization", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return types.NewOrganization(organization), nil
|
|
}
|
|
|
|
// Scopes is the resolver for the scopes field.
|
|
func (r *riskAssessmentResolver) Scopes(ctx context.Context, obj *types.RiskAssessment, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentScopeOrderBy) (*types.RiskAssessmentScopeConnection, error) {
|
|
if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentScopeList); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.ID)
|
|
pageOrderBy := page.OrderBy[coredata.RiskAssessmentScopeOrderField]{
|
|
Field: coredata.RiskAssessmentScopeOrderFieldCreatedAt,
|
|
Direction: page.OrderDirectionDesc,
|
|
}
|
|
if orderBy != nil {
|
|
pageOrderBy = page.OrderBy[coredata.RiskAssessmentScopeOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
|
|
}
|
|
cursor := types.NewCursor(first, after, last, before, pageOrderBy)
|
|
p, err := r.riskManagement.ListScopesForRiskAssessmentID(ctx, scope, obj.ID, cursor)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot list risk assessment scopes", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return types.NewRiskAssessmentScopeConnection(p, r, obj.ID), nil
|
|
}
|
|
|
|
// Permission is the resolver for the permission field.
|
|
func (r *riskAssessmentResolver) Permission(ctx context.Context, obj *types.RiskAssessment, action string) (bool, error) {
|
|
return r.Resolver.Permission(ctx, obj, action)
|
|
}
|
|
|
|
// TotalCount is the resolver for the totalCount field.
|
|
func (r *riskAssessmentConnectionResolver) TotalCount(ctx context.Context, obj *types.RiskAssessmentConnection) (*int, error) {
|
|
if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentList); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.ParentID)
|
|
count, err := r.riskManagement.CountForOrganizationID(ctx, scope, obj.ParentID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot count risk assessments", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &count, nil
|
|
}
|
|
|
|
// TotalCount is the resolver for the totalCount field.
|
|
func (r *riskAssessmentNodeConnectionResolver) TotalCount(ctx context.Context, obj *types.RiskAssessmentNodeConnection) (*int, error) {
|
|
if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentNodeList); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.ParentID)
|
|
count, err := r.riskManagement.CountNodesForScopeID(ctx, scope, obj.ParentID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot count risk assessment nodes", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &count, nil
|
|
}
|
|
|
|
// TotalCount is the resolver for the totalCount field.
|
|
func (r *riskAssessmentProcessConnectionResolver) TotalCount(ctx context.Context, obj *types.RiskAssessmentProcessConnection) (*int, error) {
|
|
if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentProcessList); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.ParentID)
|
|
count, err := r.riskManagement.CountProcessesForScopeID(ctx, scope, obj.ParentID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot count risk assessment processes", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &count, nil
|
|
}
|
|
|
|
// Scope is the resolver for the scope field.
|
|
func (r *riskAssessmentScenarioResolver) Scope(ctx context.Context, obj *types.RiskAssessmentScenario) (*types.RiskAssessmentScope, error) {
|
|
if err := r.authorize(ctx, obj.RiskAssessmentScopeID, probo.ActionRiskAssessmentScopeGet); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.RiskAssessmentScopeID)
|
|
raScope, err := r.riskManagement.GetScope(ctx, scope, obj.RiskAssessmentScopeID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot load risk assessment scope", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return types.NewRiskAssessmentScope(raScope), nil
|
|
}
|
|
|
|
// Threats is the resolver for the threats field.
|
|
func (r *riskAssessmentScenarioResolver) Threats(ctx context.Context, obj *types.RiskAssessmentScenario, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentThreatOrderBy) (*types.RiskAssessmentThreatConnection, error) {
|
|
if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentThreatList); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.ID)
|
|
pageOrderBy := page.OrderBy[coredata.RiskAssessmentThreatOrderField]{
|
|
Field: coredata.RiskAssessmentThreatOrderFieldCreatedAt,
|
|
Direction: page.OrderDirectionDesc,
|
|
}
|
|
if orderBy != nil {
|
|
pageOrderBy = page.OrderBy[coredata.RiskAssessmentThreatOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
|
|
}
|
|
cursor := types.NewCursor(first, after, last, before, pageOrderBy)
|
|
p, err := r.riskManagement.ListThreatsForScenarioID(ctx, scope, obj.ID, cursor)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot list scenario threats", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return types.NewRiskAssessmentThreatConnection(p, r, obj.ID), nil
|
|
}
|
|
|
|
// Risks is the resolver for the risks field.
|
|
func (r *riskAssessmentScenarioResolver) Risks(ctx context.Context, obj *types.RiskAssessmentScenario, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskOrderBy) (*types.RiskConnection, error) {
|
|
if err := r.authorize(ctx, obj.ID, probo.ActionRiskList); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.ID)
|
|
pageOrderBy := page.OrderBy[coredata.RiskOrderField]{
|
|
Field: coredata.RiskOrderFieldCreatedAt,
|
|
Direction: page.OrderDirectionDesc,
|
|
}
|
|
if orderBy != nil {
|
|
pageOrderBy = page.OrderBy[coredata.RiskOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
|
|
}
|
|
cursor := types.NewCursor(first, after, last, before, pageOrderBy)
|
|
p, err := r.riskManagement.ListRisksForScenarioID(ctx, scope, obj.ID, cursor)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot list scenario risks", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return types.NewRiskConnection(p, r, obj.ID, nil), nil
|
|
}
|
|
|
|
// TotalCount is the resolver for the totalCount field.
|
|
func (r *riskAssessmentScenarioConnectionResolver) TotalCount(ctx context.Context, obj *types.RiskAssessmentScenarioConnection) (*int, error) {
|
|
if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentScenarioList); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.ParentID)
|
|
|
|
switch obj.Resolver.(type) {
|
|
case *riskAssessmentScopeResolver:
|
|
count, err := r.riskManagement.CountScenariosForScopeID(ctx, scope, obj.ParentID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot count risk scenarios", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &count, nil
|
|
case *organizationResolver:
|
|
count, err := r.riskManagement.CountScenariosForOrganizationID(ctx, scope, obj.ParentID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot count risk scenarios", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &count, nil
|
|
default:
|
|
count, err := r.riskManagement.CountScenariosForRiskID(ctx, scope, obj.ParentID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot count risk scenarios", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &count, nil
|
|
}
|
|
}
|
|
|
|
// Nodes is the resolver for the nodes field.
|
|
func (r *riskAssessmentScopeResolver) Nodes(ctx context.Context, obj *types.RiskAssessmentScope, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentNodeOrderBy) (*types.RiskAssessmentNodeConnection, error) {
|
|
if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentNodeList); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.ID)
|
|
pageOrderBy := page.OrderBy[coredata.RiskAssessmentNodeOrderField]{
|
|
Field: coredata.RiskAssessmentNodeOrderFieldCreatedAt,
|
|
Direction: page.OrderDirectionDesc,
|
|
}
|
|
if orderBy != nil {
|
|
pageOrderBy = page.OrderBy[coredata.RiskAssessmentNodeOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
|
|
}
|
|
cursor := types.NewCursor(first, after, last, before, pageOrderBy)
|
|
p, err := r.riskManagement.ListNodesForScopeID(ctx, scope, obj.ID, cursor)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot list risk assessment nodes", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return types.NewRiskAssessmentNodeConnection(p, r, obj.ID), nil
|
|
}
|
|
|
|
// Processes is the resolver for the processes field.
|
|
func (r *riskAssessmentScopeResolver) Processes(ctx context.Context, obj *types.RiskAssessmentScope, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentProcessOrderBy) (*types.RiskAssessmentProcessConnection, error) {
|
|
if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentProcessList); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.ID)
|
|
pageOrderBy := page.OrderBy[coredata.RiskAssessmentProcessOrderField]{
|
|
Field: coredata.RiskAssessmentProcessOrderFieldCreatedAt,
|
|
Direction: page.OrderDirectionDesc,
|
|
}
|
|
if orderBy != nil {
|
|
pageOrderBy = page.OrderBy[coredata.RiskAssessmentProcessOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
|
|
}
|
|
cursor := types.NewCursor(first, after, last, before, pageOrderBy)
|
|
p, err := r.riskManagement.ListProcessesForScopeID(ctx, scope, obj.ID, cursor)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot list risk assessment processes", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return types.NewRiskAssessmentProcessConnection(p, r, obj.ID), nil
|
|
}
|
|
|
|
// Threats is the resolver for the threats field.
|
|
func (r *riskAssessmentScopeResolver) Threats(ctx context.Context, obj *types.RiskAssessmentScope, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentThreatOrderBy) (*types.RiskAssessmentThreatConnection, error) {
|
|
if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentThreatList); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.ID)
|
|
pageOrderBy := page.OrderBy[coredata.RiskAssessmentThreatOrderField]{
|
|
Field: coredata.RiskAssessmentThreatOrderFieldCreatedAt,
|
|
Direction: page.OrderDirectionDesc,
|
|
}
|
|
if orderBy != nil {
|
|
pageOrderBy = page.OrderBy[coredata.RiskAssessmentThreatOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
|
|
}
|
|
cursor := types.NewCursor(first, after, last, before, pageOrderBy)
|
|
p, err := r.riskManagement.ListThreatsForScopeID(ctx, scope, obj.ID, cursor)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot list risk threats", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return types.NewRiskAssessmentThreatConnection(p, r, obj.ID), nil
|
|
}
|
|
|
|
// Scenarios is the resolver for the scenarios field.
|
|
func (r *riskAssessmentScopeResolver) Scenarios(ctx context.Context, obj *types.RiskAssessmentScope, first *int, after *page.CursorKey, last *int, before *page.CursorKey, orderBy *types.RiskAssessmentScenarioOrderBy) (*types.RiskAssessmentScenarioConnection, error) {
|
|
if err := r.authorize(ctx, obj.ID, probo.ActionRiskAssessmentScenarioList); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.ID)
|
|
pageOrderBy := page.OrderBy[coredata.RiskAssessmentScenarioOrderField]{
|
|
Field: coredata.RiskAssessmentScenarioOrderFieldCreatedAt,
|
|
Direction: page.OrderDirectionDesc,
|
|
}
|
|
if orderBy != nil {
|
|
pageOrderBy = page.OrderBy[coredata.RiskAssessmentScenarioOrderField]{Field: orderBy.Field, Direction: orderBy.Direction}
|
|
}
|
|
cursor := types.NewCursor(first, after, last, before, pageOrderBy)
|
|
p, err := r.riskManagement.ListScenariosForScopeID(ctx, scope, obj.ID, cursor)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot list risk scenarios", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return types.NewRiskAssessmentScenarioConnection(p, r, obj.ID), nil
|
|
}
|
|
|
|
// TotalCount is the resolver for the totalCount field.
|
|
func (r *riskAssessmentScopeConnectionResolver) TotalCount(ctx context.Context, obj *types.RiskAssessmentScopeConnection) (*int, error) {
|
|
if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentScopeList); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.ParentID)
|
|
count, err := r.riskManagement.CountScopesForRiskAssessmentID(ctx, scope, obj.ParentID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot count risk assessment scopes", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &count, nil
|
|
}
|
|
|
|
// TotalCount is the resolver for the totalCount field.
|
|
func (r *riskAssessmentThreatConnectionResolver) TotalCount(ctx context.Context, obj *types.RiskAssessmentThreatConnection) (*int, error) {
|
|
if err := r.authorize(ctx, obj.ParentID, probo.ActionRiskAssessmentThreatList); err != nil {
|
|
return nil, err
|
|
}
|
|
scope := coredata.NewScopeFromObjectID(obj.ParentID)
|
|
|
|
switch obj.Resolver.(type) {
|
|
case *riskAssessmentScenarioResolver:
|
|
count, err := r.riskManagement.CountThreatsForScenarioID(ctx, scope, obj.ParentID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot count scenario threats", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &count, nil
|
|
default:
|
|
count, err := r.riskManagement.CountThreatsForScopeID(ctx, scope, obj.ParentID)
|
|
if err != nil {
|
|
r.logger.ErrorCtx(ctx, "cannot count risk threats", log.Error(err))
|
|
return nil, gqlutils.Internal(ctx)
|
|
}
|
|
return &count, nil
|
|
}
|
|
}
|
|
|
|
// RiskAssessment returns schema.RiskAssessmentResolver implementation.
|
|
func (r *Resolver) RiskAssessment() schema.RiskAssessmentResolver { return &riskAssessmentResolver{r} }
|
|
|
|
// RiskAssessmentConnection returns schema.RiskAssessmentConnectionResolver implementation.
|
|
func (r *Resolver) RiskAssessmentConnection() schema.RiskAssessmentConnectionResolver {
|
|
return &riskAssessmentConnectionResolver{r}
|
|
}
|
|
|
|
// RiskAssessmentNodeConnection returns schema.RiskAssessmentNodeConnectionResolver implementation.
|
|
func (r *Resolver) RiskAssessmentNodeConnection() schema.RiskAssessmentNodeConnectionResolver {
|
|
return &riskAssessmentNodeConnectionResolver{r}
|
|
}
|
|
|
|
// RiskAssessmentProcessConnection returns schema.RiskAssessmentProcessConnectionResolver implementation.
|
|
func (r *Resolver) RiskAssessmentProcessConnection() schema.RiskAssessmentProcessConnectionResolver {
|
|
return &riskAssessmentProcessConnectionResolver{r}
|
|
}
|
|
|
|
// RiskAssessmentScenario returns schema.RiskAssessmentScenarioResolver implementation.
|
|
func (r *Resolver) RiskAssessmentScenario() schema.RiskAssessmentScenarioResolver {
|
|
return &riskAssessmentScenarioResolver{r}
|
|
}
|
|
|
|
// RiskAssessmentScenarioConnection returns schema.RiskAssessmentScenarioConnectionResolver implementation.
|
|
func (r *Resolver) RiskAssessmentScenarioConnection() schema.RiskAssessmentScenarioConnectionResolver {
|
|
return &riskAssessmentScenarioConnectionResolver{r}
|
|
}
|
|
|
|
// RiskAssessmentScope returns schema.RiskAssessmentScopeResolver implementation.
|
|
func (r *Resolver) RiskAssessmentScope() schema.RiskAssessmentScopeResolver {
|
|
return &riskAssessmentScopeResolver{r}
|
|
}
|
|
|
|
// RiskAssessmentScopeConnection returns schema.RiskAssessmentScopeConnectionResolver implementation.
|
|
func (r *Resolver) RiskAssessmentScopeConnection() schema.RiskAssessmentScopeConnectionResolver {
|
|
return &riskAssessmentScopeConnectionResolver{r}
|
|
}
|
|
|
|
// RiskAssessmentThreatConnection returns schema.RiskAssessmentThreatConnectionResolver implementation.
|
|
func (r *Resolver) RiskAssessmentThreatConnection() schema.RiskAssessmentThreatConnectionResolver {
|
|
return &riskAssessmentThreatConnectionResolver{r}
|
|
}
|
|
|
|
type riskAssessmentResolver struct{ *Resolver }
|
|
type riskAssessmentConnectionResolver struct{ *Resolver }
|
|
type riskAssessmentNodeConnectionResolver struct{ *Resolver }
|
|
type riskAssessmentProcessConnectionResolver struct{ *Resolver }
|
|
type riskAssessmentScenarioResolver struct{ *Resolver }
|
|
type riskAssessmentScenarioConnectionResolver struct{ *Resolver }
|
|
type riskAssessmentScopeResolver struct{ *Resolver }
|
|
type riskAssessmentScopeConnectionResolver struct{ *Resolver }
|
|
type riskAssessmentThreatConnectionResolver struct{ *Resolver }
|