< Summary

Information
Class: AsiBackbone.AspNetCore.Endpoints.DefaultAsiBackboneEndpointGovernanceService
Assembly: AsiBackbone.AspNetCore
File(s): /home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.AspNetCore/Endpoints/DefaultAsiBackboneEndpointGovernanceService.cs
Line coverage
100%
Covered lines: 276
Uncovered lines: 0
Coverable lines: 276
Total lines: 503
Line coverage: 100%
Branch coverage
71%
Covered branches: 53
Total branches: 74
Branch coverage: 71.6%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)50%1616100%
EvaluateAsync()100%1010100%
SanitizeMetadataAsync()75%44100%
EvaluatePolicyAsync()100%66100%
ValidateCapabilityAsync()75%8880.95%
EmitAuditAsync()66.66%8664%
CreateCompletedResult(...)87.5%88100%
CreateMetadataSanitizationFailure(...)100%11100%
CreateAllowDecision(...)100%11100%
get_Metadata()100%11100%
get_TerminalResult()100%11100%
get_Decision()100%11100%
get_TerminalResult()100%11100%
get_Actor()100%11100%
get_TerminalResult()100%11100%
.ctor(...)100%11100%
GetPolicyEvaluator()50%22100%
GetCapabilityValidator()50%22100%
GetAuditSink()50%22100%
GetMetadataSanitizer()50%22100%
CreateBlockedDecisionResult(...)50%44100%
CreateConfigurationFailure(...)50%22100%
CreateCapabilityFailure(...)100%22100%

File(s)

/home/runner/work/AsiBackbone/AsiBackbone/src/AsiBackbone.AspNetCore/Endpoints/DefaultAsiBackboneEndpointGovernanceService.cs

#LineLine coverage
 1using AsiBackbone.AspNetCore.Actors;
 2using AsiBackbone.AspNetCore.Correlation;
 3using AsiBackbone.AspNetCore.Handshakes;
 4using AsiBackbone.AspNetCore.Results;
 5using AsiBackbone.Core.Actors;
 6using AsiBackbone.Core.Audit;
 7using AsiBackbone.Core.Constraints;
 8using AsiBackbone.Core.Decisions;
 9using AsiBackbone.Core.Evaluation;
 10using AsiBackbone.Core.Metadata;
 11using AsiBackbone.Core.Results;
 12using Microsoft.AspNetCore.Http;
 13using Microsoft.Extensions.DependencyInjection;
 14using Microsoft.Extensions.Options;
 15
 16namespace AsiBackbone.AspNetCore.Endpoints;
 17
 18/// <summary>
 19/// Default host-adapter implementation for ergonomic ASP.NET Core endpoint governance.
 20/// </summary>
 21public sealed class DefaultAsiBackboneEndpointGovernanceService : IAsiBackboneEndpointGovernanceService
 22{
 23    private const string MetadataSanitizationDeniedReasonCode = "endpoint.metadata_sanitization.denied";
 24    private const string MetadataSanitizationDeniedReasonMessage =
 25        "Endpoint governance metadata was denied by the configured sanitation policy.";
 26
 27    private readonly IServiceProvider serviceProvider;
 28    private readonly IAsiBackboneHttpActorContextResolver actorContextResolver;
 29    private readonly IAsiBackboneHttpRequestCorrelationResolver requestCorrelationResolver;
 30    private readonly IAsiBackboneAcknowledgmentChallengeService acknowledgmentChallengeService;
 31    private readonly AsiBackboneEndpointGovernanceOptions endpointOptions;
 32    private readonly AsiBackboneHttpResultMappingOptions resultOptions;
 33
 34    /// <summary>
 35    /// Initializes a new instance of the <see cref="DefaultAsiBackboneEndpointGovernanceService" /> class.
 36    /// </summary>
 2337    public DefaultAsiBackboneEndpointGovernanceService(
 2338        IServiceProvider serviceProvider,
 2339        IAsiBackboneHttpActorContextResolver actorContextResolver,
 2340        IAsiBackboneHttpRequestCorrelationResolver requestCorrelationResolver,
 2341        IAsiBackboneAcknowledgmentChallengeService acknowledgmentChallengeService,
 2342        IOptions<AsiBackboneEndpointGovernanceOptions> endpointOptions,
 2343        IOptions<AsiBackboneHttpResultMappingOptions> resultOptions)
 44    {
 2345        this.serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
 2346        this.actorContextResolver = actorContextResolver ?? throw new ArgumentNullException(nameof(actorContextResolver)
 2347        this.requestCorrelationResolver = requestCorrelationResolver ?? throw new ArgumentNullException(nameof(requestCo
 2348        this.acknowledgmentChallengeService = acknowledgmentChallengeService ?? throw new ArgumentNullException(nameof(a
 2349        this.endpointOptions = endpointOptions?.Value ?? throw new ArgumentNullException(nameof(endpointOptions));
 2350        this.resultOptions = resultOptions?.Value ?? throw new ArgumentNullException(nameof(resultOptions));
 2351        this.endpointOptions.Validate();
 2352        this.resultOptions.Validate();
 2353    }
 54
 55    /// <inheritdoc />
 56    public async ValueTask<AsiBackboneEndpointGovernanceResult> EvaluateAsync(
 57        HttpContext httpContext,
 58        AsiBackboneEndpointGovernanceDescriptor descriptor,
 59        CancellationToken cancellationToken = default)
 60    {
 2161        ArgumentNullException.ThrowIfNull(httpContext);
 2162        ArgumentNullException.ThrowIfNull(descriptor);
 2163        cancellationToken.ThrowIfCancellationRequested();
 64
 2065        if (!descriptor.HasGovernanceMetadata)
 66        {
 167            return AsiBackboneEndpointGovernanceResult.Allow();
 68        }
 69
 1970        var optionalServices = new EndpointGovernanceOptionalServiceResolver(
 1971            httpContext.RequestServices,
 1972            serviceProvider);
 1973        AsiBackboneHttpRequestCorrelation correlation = requestCorrelationResolver.ResolveRequestCorrelation();
 1974        IReadOnlyDictionary<string, string> endpointMetadata = descriptor.ToMetadata(endpointOptions.MetadataMode);
 75
 1976        MetadataStageResult metadataStage = await SanitizeMetadataAsync(
 1977            optionalServices,
 1978            correlation,
 1979            endpointMetadata,
 1980            cancellationToken).ConfigureAwait(false);
 81
 1982        if (metadataStage.TerminalResult is not null)
 83        {
 184            return metadataStage.TerminalResult;
 85        }
 86
 1887        endpointMetadata = metadataStage.Metadata;
 1888        AsiBackboneConstraintEvaluationContext evaluationContext = correlation.ToEvaluationContext(
 1889            endpointOptions.PolicyVersion,
 1890            endpointOptions.PolicyHash,
 1891            endpointMetadata);
 92
 1893        DecisionStageResult policyStage = await EvaluatePolicyAsync(
 1894            httpContext,
 1895            descriptor,
 1896            optionalServices,
 1897            correlation,
 1898            endpointMetadata,
 1899            evaluationContext,
 18100            cancellationToken).ConfigureAwait(false);
 101
 17102        if (policyStage.TerminalResult is not null)
 103        {
 2104            return policyStage.TerminalResult;
 105        }
 106
 15107        DecisionStageResult capabilityStage = await ValidateCapabilityAsync(
 15108            httpContext,
 15109            descriptor,
 15110            optionalServices,
 15111            endpointMetadata,
 15112            policyStage.Decision,
 15113            cancellationToken).ConfigureAwait(false);
 114
 15115        if (capabilityStage.TerminalResult is not null)
 116        {
 3117            return capabilityStage.TerminalResult;
 118        }
 119
 12120        AuditStageResult auditStage = await EmitAuditAsync(
 12121            httpContext,
 12122            descriptor,
 12123            optionalServices,
 12124            endpointMetadata,
 12125            capabilityStage.Decision,
 12126            cancellationToken).ConfigureAwait(false);
 127
 12128        return auditStage.TerminalResult is not null
 12129            ? auditStage.TerminalResult
 12130            : CreateCompletedResult(
 12131            descriptor,
 12132            endpointMetadata,
 12133            capabilityStage.Decision,
 12134            auditStage.Actor);
 19135    }
 136
 137    private async ValueTask<MetadataStageResult> SanitizeMetadataAsync(
 138        EndpointGovernanceOptionalServiceResolver optionalServices,
 139        AsiBackboneHttpRequestCorrelation correlation,
 140        IReadOnlyDictionary<string, string> endpointMetadata,
 141        CancellationToken cancellationToken)
 142    {
 19143        IGovernanceMetadataSanitizer? metadataSanitizer = optionalServices.GetMetadataSanitizer();
 19144        if (metadataSanitizer is null)
 145        {
 18146            return new MetadataStageResult(endpointMetadata, TerminalResult: null);
 147        }
 148
 1149        GovernanceMetadataSanitizationResult sanitizationResult = await metadataSanitizer
 1150            .SanitizeAsync(endpointMetadata, cancellationToken)
 1151            .ConfigureAwait(false);
 152
 1153        return sanitizationResult.CanProceed
 1154            ? new MetadataStageResult(sanitizationResult.SanitizedMetadata, TerminalResult: null)
 1155            : new MetadataStageResult(
 1156                endpointMetadata,
 1157                CreateMetadataSanitizationFailure(correlation, sanitizationResult));
 19158    }
 159
 160    private async ValueTask<DecisionStageResult> EvaluatePolicyAsync(
 161        HttpContext httpContext,
 162        AsiBackboneEndpointGovernanceDescriptor descriptor,
 163        EndpointGovernanceOptionalServiceResolver optionalServices,
 164        AsiBackboneHttpRequestCorrelation correlation,
 165        IReadOnlyDictionary<string, string> endpointMetadata,
 166        AsiBackboneConstraintEvaluationContext evaluationContext,
 167        CancellationToken cancellationToken)
 168    {
 18169        GovernanceDecision allowedDecision = CreateAllowDecision(evaluationContext, correlation.TraceId);
 18170        if (descriptor.PolicyTypes.Count == 0)
 171        {
 4172            return new DecisionStageResult(allowedDecision, TerminalResult: null);
 173        }
 174
 14175        IAsiBackbonePolicyEvaluator<AsiBackboneConstraintEvaluationContext>? evaluator =
 14176            optionalServices.GetPolicyEvaluator();
 14177        if (evaluator is null)
 178        {
 2179            AsiBackboneEndpointGovernanceResult terminalResult = endpointOptions.FailClosedWhenPolicyEvaluatorMissing
 2180                ? CreateConfigurationFailure(
 2181                    httpContext,
 2182                    descriptor,
 2183                    endpointMetadata,
 2184                    "endpoint.policy_evaluator.missing",
 2185                    "Endpoint governance policy metadata was present, but no AsiBackbone policy evaluator was registered
 2186                    allowedDecision,
 2187                    "aspnetcore.endpoint.governance.configuration.policy_evaluator")
 2188                : AsiBackboneEndpointGovernanceResult.Allow(allowedDecision);
 189
 2190            return new DecisionStageResult(allowedDecision, terminalResult);
 191        }
 192
 12193        GovernanceDecision decision = await evaluator
 12194            .EvaluateAsync(evaluationContext, cancellationToken)
 12195            .ConfigureAwait(false);
 196
 11197        return new DecisionStageResult(decision, TerminalResult: null);
 17198    }
 199
 200    private async ValueTask<DecisionStageResult> ValidateCapabilityAsync(
 201        HttpContext httpContext,
 202        AsiBackboneEndpointGovernanceDescriptor descriptor,
 203        EndpointGovernanceOptionalServiceResolver optionalServices,
 204        IReadOnlyDictionary<string, string> endpointMetadata,
 205        GovernanceDecision decision,
 206        CancellationToken cancellationToken)
 207    {
 15208        if (!decision.CanProceed || descriptor.CapabilityScopes.Count == 0)
 209        {
 8210            return new DecisionStageResult(decision, TerminalResult: null);
 211        }
 212
 7213        IAsiBackboneEndpointCapabilityGrantValidator? capabilityValidator =
 7214            optionalServices.GetCapabilityValidator();
 7215        if (capabilityValidator is null)
 216        {
 3217            AsiBackboneEndpointGovernanceResult terminalResult = endpointOptions.FailClosedWhenCapabilityValidatorMissin
 3218                ? CreateCapabilityFailure(
 3219                    httpContext,
 3220                    descriptor,
 3221                    endpointMetadata,
 3222                    "endpoint.capability_validator.missing",
 3223                    "Endpoint capability metadata was present, but no host-owned endpoint capability validator was regis
 3224                    decision,
 3225                    "aspnetcore.endpoint.governance.capability.configuration")
 3226                : AsiBackboneEndpointGovernanceResult.Allow(decision);
 227
 3228            return new DecisionStageResult(decision, terminalResult);
 229        }
 230
 4231        GovernanceDecision validatedDecision = await capabilityValidator
 4232            .ValidateAsync(httpContext, descriptor, decision, cancellationToken)
 4233            .ConfigureAwait(false);
 234
 4235        return new DecisionStageResult(validatedDecision, TerminalResult: null);
 15236    }
 237
 238    private async ValueTask<AuditStageResult> EmitAuditAsync(
 239        HttpContext httpContext,
 240        AsiBackboneEndpointGovernanceDescriptor descriptor,
 241        EndpointGovernanceOptionalServiceResolver optionalServices,
 242        IReadOnlyDictionary<string, string> endpointMetadata,
 243        GovernanceDecision decision,
 244        CancellationToken cancellationToken)
 245    {
 12246        if (!descriptor.EmitGovernanceAudit)
 247        {
 9248            return new AuditStageResult(Actor: null, TerminalResult: null);
 249        }
 250
 3251        IAsiBackboneAuditSink? auditSink = optionalServices.GetAuditSink();
 3252        if (auditSink is null)
 253        {
 1254            AsiBackboneEndpointGovernanceResult terminalResult = endpointOptions.FailClosedWhenAuditSinkMissing
 1255                ? CreateConfigurationFailure(
 1256                    httpContext,
 1257                    descriptor,
 1258                    endpointMetadata,
 1259                    "endpoint.audit_sink.missing",
 1260                    "Endpoint governance audit emission was requested, but no host-owned audit sink was registered.",
 1261                    decision,
 1262                    "aspnetcore.endpoint.governance.configuration.audit_sink")
 1263                : AsiBackboneEndpointGovernanceResult.Allow(decision);
 264
 1265            return new AuditStageResult(Actor: null, terminalResult);
 266        }
 267
 2268        IAsiBackboneActorContext actor = actorContextResolver.ResolveActorContext();
 2269        var residue = AuditResidue.FromDecision(
 2270            actor,
 2271            descriptor.OperationName,
 2272            decision,
 2273            metadata: endpointMetadata,
 2274            decisionStage: "aspnetcore.endpoint.governance");
 275
 2276        await auditSink.WriteAsync(residue, cancellationToken).ConfigureAwait(false);
 2277        return new AuditStageResult(actor, TerminalResult: null);
 12278    }
 279
 280    private AsiBackboneEndpointGovernanceResult CreateCompletedResult(
 281        AsiBackboneEndpointGovernanceDescriptor descriptor,
 282        IReadOnlyDictionary<string, string> endpointMetadata,
 283        GovernanceDecision decision,
 284        IAsiBackboneActorContext? actor)
 285    {
 11286        if (decision.RequiresAcknowledgment && descriptor.RequiresLiabilityHandshake)
 287        {
 1288            actor ??= actorContextResolver.ResolveActorContext();
 1289            AsiBackboneAcknowledgmentChallenge challenge = acknowledgmentChallengeService.CreateChallenge(
 1290                actor,
 1291                descriptor.OperationName,
 1292                decision,
 1293                endpointMetadata);
 294
 1295            IResult challengeResult = Microsoft.AspNetCore.Http.Results.Json(
 1296                challenge,
 1297                statusCode: endpointOptions.AcknowledgmentChallengeStatusCode);
 298
 1299            return AsiBackboneEndpointGovernanceResult.Challenge(challenge, challengeResult, decision);
 300        }
 301
 10302        return decision.CanProceed
 10303            ? AsiBackboneEndpointGovernanceResult.Allow(decision)
 10304            : CreateBlockedDecisionResult(decision);
 305    }
 306
 307    private AsiBackboneEndpointGovernanceResult CreateMetadataSanitizationFailure(
 308        AsiBackboneHttpRequestCorrelation correlation,
 309        GovernanceMetadataSanitizationResult sanitizationResult)
 310    {
 1311        var reasons = new List<OperationReason>(sanitizationResult.Reasons.Count + 1)
 1312        {
 1313            OperationReason.Create(
 1314                MetadataSanitizationDeniedReasonCode,
 1315                MetadataSanitizationDeniedReasonMessage)
 1316        };
 1317        reasons.AddRange(sanitizationResult.Reasons);
 318
 1319        var decision = GovernanceDecision.Deny(
 1320            reasons,
 1321            correlationId: correlation.CorrelationId,
 1322            traceId: correlation.TraceId,
 1323            policyVersion: endpointOptions.PolicyVersion,
 1324            policyHash: endpointOptions.PolicyHash);
 325
 1326        return CreateBlockedDecisionResult(decision);
 327    }
 328
 329    private static GovernanceDecision CreateAllowDecision(
 330        AsiBackboneConstraintEvaluationContext evaluationContext,
 331        string? traceId)
 332    {
 18333        return GovernanceDecision.Allow(
 18334            correlationId: evaluationContext.CorrelationId,
 18335            traceId: traceId,
 18336            policyVersion: evaluationContext.PolicyVersion,
 18337            policyHash: evaluationContext.PolicyHash);
 338    }
 339
 340    private readonly record struct MetadataStageResult(
 18341        IReadOnlyDictionary<string, string> Metadata,
 20342        AsiBackboneEndpointGovernanceResult? TerminalResult);
 343
 344    private readonly record struct DecisionStageResult(
 38345        GovernanceDecision Decision,
 37346        AsiBackboneEndpointGovernanceResult? TerminalResult);
 347
 348    private readonly record struct AuditStageResult(
 11349        IAsiBackboneActorContext? Actor,
 13350        AsiBackboneEndpointGovernanceResult? TerminalResult);
 351
 19352    private sealed class EndpointGovernanceOptionalServiceResolver(
 19353        IServiceProvider requestServices,
 19354        IServiceProvider governanceServices)
 355    {
 356        private IAsiBackbonePolicyEvaluator<AsiBackboneConstraintEvaluationContext>? policyEvaluator;
 357        private IAsiBackboneEndpointCapabilityGrantValidator? capabilityValidator;
 358        private IAsiBackboneAuditSink? auditSink;
 359        private IGovernanceMetadataSanitizer? metadataSanitizer;
 360        private bool policyEvaluatorResolved;
 361        private bool capabilityValidatorResolved;
 362        private bool auditSinkResolved;
 363        private bool metadataSanitizerResolved;
 364
 365        public IAsiBackbonePolicyEvaluator<AsiBackboneConstraintEvaluationContext>? GetPolicyEvaluator()
 366        {
 14367            if (!policyEvaluatorResolved)
 368            {
 14369                policyEvaluator = requestServices
 14370                    .GetService<IAsiBackbonePolicyEvaluator<AsiBackboneConstraintEvaluationContext>>();
 14371                policyEvaluatorResolved = true;
 372            }
 373
 14374            return policyEvaluator;
 375        }
 376
 377        public IAsiBackboneEndpointCapabilityGrantValidator? GetCapabilityValidator()
 378        {
 7379            if (!capabilityValidatorResolved)
 380            {
 7381                capabilityValidator = requestServices.GetService<IAsiBackboneEndpointCapabilityGrantValidator>();
 7382                capabilityValidatorResolved = true;
 383            }
 384
 7385            return capabilityValidator;
 386        }
 387
 388        public IAsiBackboneAuditSink? GetAuditSink()
 389        {
 3390            if (!auditSinkResolved)
 391            {
 3392                auditSink = governanceServices.GetService<IAsiBackboneAuditSink>();
 3393                auditSinkResolved = true;
 394            }
 395
 3396            return auditSink;
 397        }
 398
 399        public IGovernanceMetadataSanitizer? GetMetadataSanitizer()
 400        {
 19401            if (!metadataSanitizerResolved)
 402            {
 19403                metadataSanitizer = requestServices.GetService<IGovernanceMetadataSanitizer>();
 19404                metadataSanitizerResolved = true;
 405            }
 406
 19407            return metadataSanitizer;
 408        }
 409    }
 410
 411    private AsiBackboneEndpointGovernanceResult CreateBlockedDecisionResult(GovernanceDecision decision)
 412    {
 7413        return decision.IsDenied && resultOptions.DeniedStatusCode == StatusCodes.Status403Forbidden
 7414            ? AsiBackboneEndpointGovernanceResult.BlockWithDefaultFailure(decision)
 7415            : AsiBackboneEndpointGovernanceResult.Block(decision.ToHttpResult(resultOptions), decision);
 416    }
 417
 418    private AsiBackboneEndpointGovernanceResult CreateConfigurationFailure(
 419        HttpContext httpContext,
 420        AsiBackboneEndpointGovernanceDescriptor descriptor,
 421        IReadOnlyDictionary<string, string> metadata,
 422        string code,
 423        string message,
 424        GovernanceDecision currentDecision,
 425        string decisionStage)
 426    {
 2427        var decision = GovernanceDecision.Deny(
 2428            code,
 2429            message,
 2430            correlationId: currentDecision.CorrelationId,
 2431            traceId: currentDecision.TraceId,
 2432            policyVersion: currentDecision.PolicyVersion,
 2433            policyHash: currentDecision.PolicyHash);
 434
 2435        return AsiBackboneEndpointGovernanceDevelopmentDiagnostics.IsEnabled(httpContext, endpointOptions)
 2436            ? AsiBackboneEndpointGovernanceResult.Block(
 2437                AsiBackboneEndpointGovernanceDevelopmentDiagnostics.CreateProblem(
 2438                    httpContext,
 2439                    endpointOptions,
 2440                    descriptor,
 2441                    decision,
 2442                    decisionStage,
 2443                    title: "Endpoint governance configuration is incomplete.",
 2444                    detail: message,
 2445                    statusCode: endpointOptions.ConfigurationFailureStatusCode,
 2446                    metadata: metadata),
 2447                decision)
 2448            : AsiBackboneEndpointGovernanceResult.Block(
 2449                Microsoft.AspNetCore.Http.Results.Problem(
 2450                    title: "Endpoint governance configuration is incomplete.",
 2451                    detail: message,
 2452                    statusCode: endpointOptions.ConfigurationFailureStatusCode,
 2453                    extensions: new Dictionary<string, object?>(StringComparer.Ordinal)
 2454                    {
 2455                        ["reasonCodes"] = decision.ReasonCodes,
 2456                        ["outcome"] = decision.Outcome.ToString()
 2457                    }),
 2458                decision);
 459    }
 460
 461    private AsiBackboneEndpointGovernanceResult CreateCapabilityFailure(
 462        HttpContext httpContext,
 463        AsiBackboneEndpointGovernanceDescriptor descriptor,
 464        IReadOnlyDictionary<string, string> metadata,
 465        string code,
 466        string message,
 467        GovernanceDecision currentDecision,
 468        string decisionStage)
 469    {
 3470        var decision = GovernanceDecision.Deny(
 3471            code,
 3472            message,
 3473            correlationId: currentDecision.CorrelationId,
 3474            traceId: currentDecision.TraceId,
 3475            policyVersion: currentDecision.PolicyVersion,
 3476            policyHash: currentDecision.PolicyHash);
 477
 3478        return AsiBackboneEndpointGovernanceDevelopmentDiagnostics.IsEnabled(httpContext, endpointOptions)
 3479            ? AsiBackboneEndpointGovernanceResult.Block(
 3480                AsiBackboneEndpointGovernanceDevelopmentDiagnostics.CreateProblem(
 3481                    httpContext,
 3482                    endpointOptions,
 3483                    descriptor,
 3484                    decision,
 3485                    decisionStage,
 3486                    title: "Endpoint capability grant validation failed.",
 3487                    detail: message,
 3488                    statusCode: endpointOptions.CapabilityFailureStatusCode,
 3489                    metadata: metadata),
 3490                decision)
 3491            : AsiBackboneEndpointGovernanceResult.Block(
 3492                Microsoft.AspNetCore.Http.Results.Problem(
 3493                    title: "Endpoint capability grant validation failed.",
 3494                    detail: message,
 3495                    statusCode: endpointOptions.CapabilityFailureStatusCode,
 3496                    extensions: new Dictionary<string, object?>(StringComparer.Ordinal)
 3497                    {
 3498                        ["reasonCodes"] = decision.ReasonCodes,
 3499                        ["outcome"] = decision.Outcome.ToString()
 3500                    }),
 3501                decision);
 502    }
 503}
Generated by: ReportGenerator 5.5.11.0
08/15/2026 - 11:47:27
GitHub | reportgenerator.io

Methods/Properties

.ctor(System.IServiceProvider,AsiBackbone.AspNetCore.Actors.IAsiBackboneHttpActorContextResolver,AsiBackbone.AspNetCore.Correlation.IAsiBackboneHttpRequestCorrelationResolver,AsiBackbone.AspNetCore.Handshakes.IAsiBackboneAcknowledgmentChallengeService,Microsoft.Extensions.Options.IOptions`1<AsiBackbone.AspNetCore.Endpoints.AsiBackboneEndpointGovernanceOptions>,Microsoft.Extensions.Options.IOptions`1<AsiBackbone.AspNetCore.Results.AsiBackboneHttpResultMappingOptions>)
EvaluateAsync()
SanitizeMetadataAsync()
EvaluatePolicyAsync()
ValidateCapabilityAsync()
EmitAuditAsync()
CreateCompletedResult(AsiBackbone.AspNetCore.Endpoints.AsiBackboneEndpointGovernanceDescriptor,System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>,AsiBackbone.Core.Decisions.GovernanceDecision,AsiBackbone.Core.Actors.IAsiBackboneActorContext)
CreateMetadataSanitizationFailure(AsiBackbone.AspNetCore.Correlation.AsiBackboneHttpRequestCorrelation,AsiBackbone.Core.Metadata.GovernanceMetadataSanitizationResult)
CreateAllowDecision(AsiBackbone.Core.Constraints.AsiBackboneConstraintEvaluationContext,System.String)
get_Metadata()
get_TerminalResult()
get_Decision()
get_TerminalResult()
get_Actor()
get_TerminalResult()
.ctor(System.IServiceProvider,System.IServiceProvider)
GetPolicyEvaluator()
GetCapabilityValidator()
GetAuditSink()
GetMetadataSanitizer()
CreateBlockedDecisionResult(AsiBackbone.Core.Decisions.GovernanceDecision)
CreateConfigurationFailure(Microsoft.AspNetCore.Http.HttpContext,AsiBackbone.AspNetCore.Endpoints.AsiBackboneEndpointGovernanceDescriptor,System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>,System.String,System.String,AsiBackbone.Core.Decisions.GovernanceDecision,System.String)
CreateCapabilityFailure(Microsoft.AspNetCore.Http.HttpContext,AsiBackbone.AspNetCore.Endpoints.AsiBackboneEndpointGovernanceDescriptor,System.Collections.Generic.IReadOnlyDictionary`2<System.String,System.String>,System.String,System.String,AsiBackbone.Core.Decisions.GovernanceDecision,System.String)