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
}
