public ValueTask InvokeAsync(IMiddlewareContext context) { if (context.Result is SerializedData s) { context.Result = s.Data is IReadOnlyDictionary <string, object> d ? d : DictionaryDeserializer.DeserializeResult( context.Selection.Type, s.Data, context.Service <InputParser>(), context.Path); } else if (context.Result is null && !context.Selection.Field.Directives.Contains(DirectiveNames.Computed) && context.Parent <object>() is IReadOnlyDictionary <string, object> dict) { string responseName = context.Selection.SyntaxNode.Alias == null ? context.Selection.SyntaxNode.Name.Value : context.Selection.SyntaxNode.Alias.Value; dict.TryGetValue(responseName, out var obj); context.Result = DictionaryDeserializer.DeserializeResult( context.Selection.Type, obj, context.Service <InputParser>(), context.Path); } return(_next.Invoke(context)); }
public async Task InvokeAsync(IMiddlewareContext context) { await _next(context).ConfigureAwait(false); if (context.Result is IAsyncEnumerable <T> ae) { await using IAsyncEnumerator <T> enumerator = ae.GetAsyncEnumerator(context.RequestAborted); if (await enumerator.MoveNextAsync().ConfigureAwait(false)) { context.Result = enumerator.Current; } else { context.Result = default(T) !; } } else if (context.Result is IEnumerable <T> e) { context.Result = await Task .Run(() => e.FirstOrDefault(), context.RequestAborted) .ConfigureAwait(false); } }
public override void ResolverError( IMiddlewareContext context, IError error ) { _logger.LogError(error.Exception, $"During execution of the operation {context.Operation} the error {ConvertErrorToString(error)} occurred."); }
public async Task InvokeAsync(IMiddlewareContext context) { await _next(context).ConfigureAwait(false); IValueNode sortArgument = context.Argument <IValueNode>(_contextData.ArgumentName); if (sortArgument is null || sortArgument is NullValueNode) { return; } IQueryable <T>?source = null; if (context.Result is IQueryable <T> q) { source = q; } else if (context.Result is IEnumerable <T> e) { source = e.AsQueryable(); } if (source is not null && context.Field.Arguments[_contextData.ArgumentName].Type is InputObjectType iot && iot is ISortInputType fit && fit.EntityType is { })
public async Task InvokeAsync(IMiddlewareContext context) { await _next(context).ConfigureAwait(false); IValueNode filter = context.ArgumentLiteral <IValueNode>(_contextData.ArgumentName); if (filter is NullValueNode) { return; } IQueryable <T>?source = null; if (context.Result is IQueryable <T> q) { source = q; } else if (context.Result is IEnumerable <T> e) { source = e.AsQueryable(); } if (source is not null && context.Field.Arguments[_contextData.ArgumentName].Type is InputObjectType iot && iot is IFilterInputType fit) { var visitorContext = new QueryableFilterVisitorContext( iot, fit.EntityType, _converter, source is EnumerableQuery); QueryableFilterVisitor.Default.Visit(filter, visitorContext); source = source.Where(visitorContext.CreateFilter <T>()); context.Result = source; } }
public override IEnumerable <ResolvedValidator> GetValidators( IMiddlewareContext context, IInputField argument) { yield return(new ResolvedValidator( new RequiresOwnScopeValidator(), _mockScope)); }
public async Task InvokeAsync(IMiddlewareContext context) { var queryAuthorizationService = context.Service <IServiceProvider>().GetService <IQueryAuthorizationService>(); if (queryAuthorizationService != null) { var authorizationResult = await queryAuthorizationService.IsAllowedAsync(queryType); if (authorizationResult != AuthorizationResult.Allowed) { var eb = ErrorBuilder.New() .SetMessage(authorizationResult == AuthorizationResult.Unauthorized ? "Unauthorized" : "Forbidden") .SetCode("AuthorizationResult") .SetExtension("StatusCode", authorizationResult == AuthorizationResult.Unauthorized ? "401" : "403") .SetPath(context.Path) .AddLocation(context.Selection.SyntaxNode); context.Result = eb.Build(); return; } } await _next.Invoke(context); }
public async Task InvokeAsync(IMiddlewareContext context) { await _next(context).ConfigureAwait(false); var pagingDetails = new PagingDetails { First = context.ArgumentValue <int?>("first"), After = context.ArgumentValue <string>("after"), Last = context.ArgumentValue <int?>("last"), Before = context.ArgumentValue <string>("before"), }; IQueryable <T> source = context.Result switch { IQueryable <T> q => q, IEnumerable <T> e => e.AsQueryable(), _ => null }; if (source != null) { IConnectionResolver connectionResolver = _createConnectionResolver( source, pagingDetails); context.Result = await connectionResolver .ResolveAsync(context.RequestAborted) .ConfigureAwait(false); } }
public void Validate(object instance, IMiddlewareContext context) { ValidationContext validationContext = new ValidationContext(instance); if (instance != null) { foreach (PropertyInfo propInfo in instance.GetType().GetRuntimeProperties()) { foreach (ValidationAttribute validationAttr in propInfo.GetCustomAttributes().OfType <ValidationAttribute>()) { validationContext.DisplayName = propInfo.Name; object value = propInfo.GetValue(instance); ValidationResult result = validationAttr.GetValidationResult(value, validationContext); if (result != null) { Dictionary <string, object> extensions = new Dictionary <string, object>(); foreach (PropertyInfo argPropInfo in validationAttr.GetType().GetTypeInfo().DeclaredProperties) { extensions[argPropInfo.Name] = argPropInfo.GetValue(validationAttr); } extensions.Add("key", "ValidationError"); extensions.Add("field", propInfo.Name); extensions.Add("validator", validationAttr.GetType().Name); context.ReportError( new Error(result.ErrorMessage, "ValidationError", context.Path, extensions: extensions) ); } } } } }
public async Task InvokeAsync(IMiddlewareContext context) { TDataLoader dataloader = context.DataLoader <TDataLoader>(); await _next(context).ConfigureAwait(false); if (context.Result is IReadOnlyCollection <TKey> values) { IReadOnlyList <TValue[]> data = await dataloader .LoadAsync(values, context.RequestAborted) .ConfigureAwait(false); var result = new HashSet <object>(); for (var m = 0; m < data.Count; m++) { for (var n = 0; n < data[m].Length; n++) { result.Add(data[m][n] !); } } context.Result = result; } else if (context.Result is TKey value) { context.Result = await dataloader .LoadAsync(value, context.RequestAborted) .ConfigureAwait(false); } }
private static IReadOnlyCollection <Delegation.VariableValue> CreateVariableValues( IMiddlewareContext context, NameString schemaName, IEnumerable <Delegation.VariableValue> scopedVariables, ExtractedField extractedField, ExtractFieldQuerySyntaxRewriter rewriter) { var values = new Dictionary <string, Delegation.VariableValue>(); foreach (Delegation.VariableValue value in scopedVariables) { values[value.Name] = value; } IReadOnlyDictionary <string, IValueNode> requestVariables = context.GetVariables(); foreach (Delegation.VariableValue value in ResolveUsedRequestVariables( context.Schema, schemaName, extractedField, requestVariables, rewriter)) { values[value.Name] = value; } return(values.Values); }
public async Task InvokeAsync(IMiddlewareContext context) { if (context.ContextData.TryGetValue(BewitTokenHeader.Value, out var objectToken) && objectToken is string bewitToken) { try { object payload = await _tokenValidator.ValidateBewitTokenAsync( new BewitToken <T>(bewitToken), context.RequestAborted); _httpContextAccessor.SetBewitPayload(payload); } catch (Exception ex) { CreateError(context, ex); } await _next(context); } else { CreateError(context); } }
public SkipValidationContext( IMiddlewareContext middlewareContext, IInputField argument) { MiddlewareContext = middlewareContext; Argument = argument; }
/// <summary> /// Verify whether token stored inside HTTP request header is valid and leads to an authorized user. /// </summary> /// <param name="context">Middleware context used in resolving.</param> /// <returns>Task result of the request.</returns> public async Task InvokeAsync(IMiddlewareContext context) { var token = _tokenizer.GetToken(); var user = _tokenizer.GetUser(); if (token == null) { context.ReportError(ErrorBuilder.New() .SetCode(AuthorizationErrorCodes.NoToken.ToString()) .SetMessage("No authorization token provided!") .Build()); return; } if (user == null) { context.ReportError(ErrorBuilder.New() .SetCode(AuthorizationErrorCodes.NoAssociatedUser.ToString()) .SetMessage("Provided authorization token isn't associated with a valid user!") .Build()); return; } await _next(context); }
public async Task InvokeAsync(IMiddlewareContext context) { DelegateDirective delegateDirective = context.Field .Directives[DirectiveNames.Delegate] .FirstOrDefault()?.ToObject <DelegateDirective>(); if (delegateDirective != null) { IImmutableStack <SelectionPathComponent> path = delegateDirective.Path is null ? ImmutableStack <SelectionPathComponent> .Empty : SelectionPathParser.Parse(delegateDirective.Path); IReadOnlyQueryRequest request = CreateQuery(context, delegateDirective.Schema, path); IReadOnlyQueryResult result = await ExecuteQueryAsync( context, request, delegateDirective.Schema) .ConfigureAwait(false); UpdateContextData(context, result, delegateDirective); context.Result = new SerializedData( ExtractData(result.Data, path.Count())); ReportErrors(context, result.Errors); } await _next.Invoke(context).ConfigureAwait(false); }
public async Task InvokeAsync(IMiddlewareContext context) { await _next(context).ConfigureAwait(false); var page = context.Argument <int?>("page") ?? 1; if (page <= 0) { page = 1; } var pageSize = context.Argument <int?>("pageSize") ?? 10; var source = context.Result switch { IQueryable <TValueType> q => q, IEnumerable <TValueType> e => e.AsQueryable(), _ => null }; if (source != null) { context.Result = new OffsetPaging <TValueType> { TotalCount = source.LongCount(), Edges = source .Skip((page - 1) * pageSize) .Take(pageSize) .ToList() }; } } }
public static bool ShouldValidateBasedOnValidateDescriptor(IMiddlewareContext context, IInputField argument) { // If argument itself was annotated if (IsValidateDescriptorApplied(argument.ContextData)) { return(true); } // If argument's input type was annotated if (argument.Type.InnerType() is InputObjectType inputType && IsValidateDescriptorApplied(inputType)) { return(true); } // If argument's clr type was annotated if (ClrTypesMarkedWithValidate.Cache.GetOrAdd( argument.RuntimeType, clrType => clrType.GetCustomAttribute <ValidateAttribute>(inherit: true) != null)) { return(true); } return(false); }
public async Task InvokeAsync(IMiddlewareContext context) { var fieldName = context.Field.Name; var objectType = context.ObjectType.Name; var contextAccessor = context.Service <IHttpContextAccessor>(); if (!contextAccessor.HttpContext.User.Identity.IsAuthenticated) { context.Result = ErrorBuilder.New() .SetMessage("Forbidden") .SetCode("503") .SetPath(context.Path) .AddLocation(context.FieldSelection) .Build(); return; } if (fieldName.Value == "PostalCode" && objectType.Value == "Restaurant") { context.Result = ErrorBuilder.New() .SetMessage("Forbidden") .SetCode("503") .SetPath(context.Path) .AddLocation(context.FieldSelection) .Build(); return; } await _next.Invoke(context); }
public virtual IEnumerable <ResolvedValidator> GetValidators(IMiddlewareContext context, IInputField argument) { if (!argument.ContextData.TryGetValue( WellKnownContextData.ValidatorDescriptors, out var validatorDescriptorsRaw) || validatorDescriptorsRaw is not IEnumerable <ValidatorDescriptor> validatorDescriptors) { yield break; } foreach (var validatorDescriptor in validatorDescriptors) { if (validatorDescriptor.RequiresOwnScope) { var scope = context.Services.CreateScope(); // disposed by middleware var validator = (IValidator)scope.ServiceProvider.GetRequiredService(validatorDescriptor.ValidatorType); yield return(new ResolvedValidator(validator, scope)); } else { var validator = (IValidator)context.Services.GetRequiredService(validatorDescriptor.ValidatorType); yield return(new ResolvedValidator(validator)); } } }
public async Task InvokeAsync(IMiddlewareContext context) { var queryArgument = context.ArgumentValue <object>("params"); if (queryArgument != null) { var service = context.Service <IGraphQLValidationService>(); var result = await service.ValidateObjectAsync(queryArgument, context.RequestAborted); if (!result.IsValid) { var eb = ErrorBuilder.New() .SetMessage("There are some validations errors") .SetCode("ValidationError") .SetPath(context.Path) .AddLocation(context.Selection.SyntaxNode); foreach (var error in result.Errors) { eb.SetExtension(error.Field, error.Errors); } context.Result = eb.Build(); return; } } await _next.Invoke(context); }
private static async Task <AuthorizeResult> AuthorizeWithPolicyAsync( IMiddlewareContext context, AuthorizeDirective directive, ClaimsPrincipal principal) { IServiceProvider services = context.Service <IServiceProvider>(); IAuthorizationService?authorizeService = services.GetService <IAuthorizationService>(); IAuthorizationPolicyProvider?policyProvider = services.GetService <IAuthorizationPolicyProvider>(); if (authorizeService == null || policyProvider == null) { // authorization service is not configured so the user is // authorized with the previous checks. return(string.IsNullOrWhiteSpace(directive.Policy) ? AuthorizeResult.Allowed : AuthorizeResult.NotAllowed); } AuthorizationPolicy?policy = null; if ((directive.Roles is null || directive.Roles.Count == 0) && string.IsNullOrWhiteSpace(directive.Policy)) { policy = await policyProvider.GetDefaultPolicyAsync() .ConfigureAwait(false); if (policy == null) { return(AuthorizeResult.NoDefaultPolicy); } }
private void SetupContext(string method) { var request = new Mock <IMiddlewareRequest>(); request.Setup(c => c.Method).Returns(method); request.Setup(c => c.PathBase).Returns("/basePath123"); request.Setup(c => c.ReadFormAsync()).Returns(Task.FromResult <IDictionary <string, string[]> >(new Dictionary <string, string[]> { { "id", new[] { "12" } } })); var response = new Mock <IMiddlewareResponse>(); response.SetupSet(c => c.StatusCode = It.IsAny <int>()).Callback <int>(c => statusCode = c); response.SetupSet(c => c.ContentType = It.IsAny <string>()).Callback <string>(c => content = c); response.Setup(c => c.Redirect(It.IsAny <string>())).Callback <string>(c => location = c); response.Setup(c => c.WriteAsync(It.IsAny <string>())).Callback <string>(c => responsebody = c); var services = new ServiceCollection(); services.AddSingleton(new RazorPage1()); var mockContext = new Mock <IMiddlewareContext>(); mockContext.Setup(c => c.Request).Returns(request.Object); mockContext.Setup(c => c.Response).Returns(response.Object); mockContext.Setup(c => c.InternalServiceProvider).Returns(services.BuildServiceProvider()); mockContext.Setup(c => c.UriMatch).Returns(Regex.Match("abc", "[a-z]*")); context = mockContext.Object; }
public async Task InvokeAsync(IMiddlewareContext context) { IFieldCollection <IInputField> arguments = context.Selection.Field.Arguments; foreach (IInputField argument in arguments) { var value = context.ArgumentValue <object?>(argument.Name) !; Type actualType = value.GetType(); if (argument.RuntimeType != actualType) { context.ReportError($"RuntimeType ({argument.RuntimeType}) not equal to actual type ({actualType})"); } if (context.Selection.Field.Name.Value.StartsWith("array")) { if (!argument.RuntimeType.IsArray) { context.ReportError($"Field defined with array but ArgDeg saying it's a {argument.RuntimeType}"); } if (!actualType.IsArray) { context.ReportError($"Field defined with array but actual type is a {actualType}"); } } } await _next(context); }
public Task InvokeAsync(IMiddlewareContext context) { context.Result = "worked"; return(Task.CompletedTask); ; }
protected virtual IErrorBuilder CreateErrorBuilder( IMiddlewareContext context, string argumentName, IValidator validator, ValidationFailure failure) { var builder = ErrorBuilder.New() .SetPath(context.Path) .SetMessage(failure.ErrorMessage) .SetCode("FairyBread_ValidationError") .SetExtension("argumentName", argumentName) .SetExtension("validatorName", validator.GetType().Name) .SetExtension("errorCode", failure.ErrorCode) .SetExtension("errorMessage", failure.ErrorMessage) .SetExtension("attemptedValue", failure.AttemptedValue) .SetExtension("severity", failure.Severity) .SetExtension("formattedMessagePlaceholderValues", failure.FormattedMessagePlaceholderValues); if (!string.IsNullOrWhiteSpace(failure.PropertyName)) { builder = builder .SetExtension("propertyName", failure.PropertyName); } return(builder); }
/// <summary> /// Set form values and run save action if request is a POST /// </summary> ///<inheritdoc/> public async Task Dispatch(IMiddlewareContext context, ILoggingService loggingService) { Check.NotNull(context, nameof(context)); Check.NotNull(loggingService, nameof(loggingService)); var request = context.Request; var response = context.Response; if (!"POST".Equals(request.Method, StringComparison.OrdinalIgnoreCase)) { response.StatusCode = (int)HttpStatusCode.MethodNotAllowed; return; } TPage page = context.InternalServiceProvider.GetRequiredService <TPage>(); page.LoggingService = loggingService; var form = await context.Request.ReadFormAsync().ConfigureAwait(false); page.Assign(context); page.SetForm(form); IMiddlewareDispatcher result = page.Save(); await result.Dispatch(context, loggingService).ConfigureAwait(false); }
public void ResolverError(IMiddlewareContext context, IError error) { for (var i = 0; i < _listeners.Length; i++) { _listeners[i].ResolverError(context, error); } }
public RabbitMiddleware(IMiddlewareContext context, ILogger logger, IApplicationService application, IEmailService email, IPhoneService phone) : base(context, logger) { Application = application ?? throw new ArgumentNullException(nameof(application)); Email = email ?? throw new ArgumentNullException(nameof(email)); Phone = phone ?? throw new ArgumentNullException(nameof(phone)); }
public override IEnumerable <ResolvedValidator> GetValidators(IMiddlewareContext context, IInputField argument) { var validators = base.GetValidators(context, argument); var standardValidator = validators.Where(v => v.Validator is StandardValidator).Single(); var anotherStandardValidator = validators.Where(v => v.Validator is AnotherStandardValidator).Single(); Assert.Null(standardValidator.Scope); Assert.Null(anotherStandardValidator.Scope); Assert.Equal(standardValidator.Scope, anotherStandardValidator.Scope); var ownScopeValidator = validators.Where(v => v.Validator is RequiresOwnScopeValidator).Single(); Assert.NotNull(ownScopeValidator.Scope); Assert.NotEqual(standardValidator.Scope, ownScopeValidator.Scope); var anotherOwnScopeValidator = validators.Where(v => v.Validator is AnotherRequiresOwnScopeValidator).Single(); Assert.NotNull(anotherOwnScopeValidator.Scope); Assert.NotEqual(standardValidator.Scope, anotherOwnScopeValidator.Scope); Assert.NotEqual(ownScopeValidator.Scope, anotherOwnScopeValidator.Scope); return(validators); }
protected virtual void HandleInvalid(IMiddlewareContext context, ValidationResult result) { foreach (var failure in result.Errors) { HandleFailure(context, failure); } }