public void BeforeExecute(ICallExecutionContext context) { var instance = context.Parameters[_index]; var validationContext = new ValidationContext(instance, context.HttpContext.RequestServices, null); var validationResults = new List <ValidationResult>(); if (!Validator.TryValidateObject(instance, validationContext, validationResults, true)) { var errorMessage = validationResults.Aggregate("", (current, result) => { if (!string.IsNullOrEmpty(result.ErrorMessage)) { current += result.ErrorMessage + Environment.NewLine; } return(current); }); if (context.ResponseMessage is ErrorResponseMessage currentResponse) { errorMessage += currentResponse.Error; } context.ContinueCall = false; context.ResponseMessage = new ErrorResponseMessage(JsonRpcErrorCode.InvalidRequest, errorMessage, context.RequestMessage.Version, context.RequestMessage.Id); } }
public void BeforeExecute(ICallExecutionContext context) { var validationValue = context.Parameters[_index]; var validationErrorMessage = ImmutableLinkedList <string> .Empty; foreach (var validationAttribute in _attributes) { var validationContext = new ValidationContext(context.Instance, context.HttpContext.RequestServices, null); var result = validationAttribute.GetValidationResult(validationValue, validationContext); if (result != ValidationResult.Success) { validationErrorMessage = validationErrorMessage.Add(validationAttribute.FormatErrorMessage(_fieldName).Replace("field", "parameter")); } } if (validationErrorMessage != ImmutableLinkedList <string> .Empty) { context.ContinueCall = false; var errorMessage = validationErrorMessage.Aggregate((v, c) => v + Environment.NewLine + c); if (context.ResponseMessage is ErrorResponseMessage currentResponse) { errorMessage += currentResponse.Error; } context.ResponseMessage = new ErrorResponseMessage(JsonRpcErrorCode.InvalidRequest, errorMessage, context.RequestMessage.Version, context.RequestMessage.Id); } }
private static void SetErrorResponse(ICallExecutionContext context, string errorMessage) { context.ContinueCall = false; if (context.ResponseMessage is ErrorResponseMessage currentError) { errorMessage = currentError.Error + errorMessage; } context.ResponseMessage = new ErrorResponseMessage(JsonRpcErrorCode.InvalidRequest, errorMessage, context.RequestMessage.Version, context.RequestMessage.Id); }
public void BeforeExecute(ICallExecutionContext context) { var objectValue = context.Parameters[_parameterIndex]; if (objectValue == null) { if (_required) { SetErrorResponse(context, $"{_parameterName} is required"); } return; } var validationErrors = ImmutableLinkedList <ValidationFailure> .Empty; var value = (T)objectValue; for (var i = 0; i < _validators.Length; i++) { var result = _validators[i].Validate(value); if (!result.IsValid) { validationErrors = validationErrors.AddRange(result.Errors); } } if (validationErrors == ImmutableLinkedList <ValidationFailure> .Empty) { return; } var errorMessage = $"Validation Errors {_parameterName}" + Environment.NewLine; var failed = false; foreach (var failure in validationErrors) { if (failure.Severity == Severity.Error) { failed = true; } errorMessage += failure.ErrorMessage; } if (failed) { SetErrorResponse(context, errorMessage); } }
/// <summary> /// Called after the execution /// </summary> /// <param name="context"></param> public void AfterExecute(ICallExecutionContext context) { }
/// <summary> /// Called before the execution happens. /// </summary> /// <param name="context"></param> public void BeforeExecute(ICallExecutionContext context) { }
public Task <bool> AsyncAuthorize(ICallExecutionContext context) { return(context.HttpContext.RequestServices.GetRequiredService <IAuthorizationService>(). AuthorizeAsync(context.HttpContext.User, _policy)); }
public async Task HandleException(ICallExecutionContext context, Exception exception) { // rollback transaction }
public async Task AfterExecute(ICallExecutionContext context) { // commit transaction }
public void AfterExecute(ICallExecutionContext context) { ExecuteCount++; }
public async Task AfterExecute(ICallExecutionContext context) { _connectionManager.CommitTransaction(); }
public Task <bool> AsyncAuthorize(ICallExecutionContext context) { return(Task.FromResult(context.HttpContext.User?.Identity?.IsAuthenticated ?? false)); }
private static IEnumerable <ICallFilter> CreateFilter <T>(ICallExecutionContext context) where T : ICallFilter { yield return(ActivatorUtilities.GetServiceOrCreateInstance <T>(context.HttpContext.RequestServices)); }
public void BeforeExecute(ICallExecutionContext context) { ExecuteCount++; }
/// <summary> /// Handle exception /// </summary> /// <param name="context"></param> /// <param name="exception"></param> public void HandleException(ICallExecutionContext context, Exception exception) { }
public async Task BeforeExecute(ICallExecutionContext context) { _connectionManager.BeginTransaction(); }
public Task <bool> AsyncAuthorize(ICallExecutionContext context) { return(Task.FromResult(context.HttpContext.User?.IsInRole(_role) ?? false)); }
public async Task HandleException(ICallExecutionContext context, Exception exception) { _connectionManager.RollbackTransaction(); }
public async Task BeforeExecute(ICallExecutionContext context) { // open transaction }