func()

in pkg/gcv/result.go [190:241]

• 44 lines of code
• 9 McCabe index (conditional complexity)

func (cv *ConstraintViolation) toViolation(name string, auxMetadata map[string]interface{}) (*validator.Violation, error) {
	metadataJson, err := json.Marshal(cv.metadata(auxMetadata))
	if err != nil {
		return nil, errors.Wrapf(err, "failed to marshal result metadata %v to json", cv.Metadata)
	}
	metadata := &structpb.Value{}
	if err := protojson.Unmarshal(metadataJson, metadata); err != nil {
		return nil, errors.Wrapf(err, "failed to unmarshal json %s into structpb", string(metadataJson))
	}

	// Extract the object fields if they exists.
	var apiVersion string
	if constraintAPIVersion, ok := cv.Constraint.Object["apiVersion"]; ok {
		apiVersion = fmt.Sprintf("%s", constraintAPIVersion)
	}

	var kind string
	if constraintKind, ok := cv.Constraint.Object["kind"]; ok {
		kind = fmt.Sprintf("%s", constraintKind)
	}

	var pbMetadata *structpb.Value
	if constraintMetadata, ok := cv.Constraint.Object["metadata"]; ok {
		if pbMetadata, err = convertToProtoVal(constraintMetadata); err != nil {
			return nil, errors.Wrapf(err, "failed to convert constraint metadata into structpb.Value")
		}
	}

	var pbSpec *structpb.Value
	if constraintSpec, ok := cv.Constraint.Object["spec"]; ok {
		if pbSpec, err = convertToProtoVal(constraintSpec); err != nil {
			return nil, errors.Wrapf(err, "failed to convert constraint spec into structpb.Value")
		}
	}

	// Build the ConstraintConfig proto.
	constraintConfig := &validator.Constraint{
		ApiVersion: apiVersion,
		Kind:       kind,
		Metadata:   pbMetadata,
		Spec:       pbSpec,
	}

	return &validator.Violation{
		Constraint:       cv.name(),
		ConstraintConfig: constraintConfig,
		Resource:         name,
		Message:          cv.Message,
		Metadata:         metadata,
		Severity:         cv.Severity,
	}, nil
}