/// <summary>
/// Execute filter.
/// </summary>
/// <param name="context">Application context.</param>
/// <param name="next">Next delegate.</param>
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
if (!context.ModelState.IsValid)
{
var errorsInModelState = context.ModelState
.Where(x => x.Value.Errors.Count > 0)
.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Errors.Select(x => x.ErrorMessage)).ToArray();
var errorResponse = new ErrorResponse();
foreach (var error in errorsInModelState)
{
foreach (var subError in error.Value)
{
var errorModel = new ValidationErrorModel
{
Field = error.Key,
Message = subError
};
errorResponse.Errors.Add(errorModel);
}
}
context.Result = new BadRequestObjectResult(errorResponse);
return;
}
await next();
}
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate nextAsync)
{
if (context.ModelState.IsValid)
{
var resultContext = await nextAsync();
}
var error = new ValidationErrorModel();
foreach (var key in context.ModelState.Keys)
{
var state = context.ModelState[key];
if (state.ValidationState != ModelValidationState.Invalid)
{
continue;
}
var errors = state.Errors.Select(p => p.ErrorMessage).ToList();
error.Errors.AddRange(errors);
if (!error.FieldErrors.ContainsKey(key))
{
error.FieldErrors.Add(key, errors);
}
}
context.Result = new BadRequestObjectResult(error);
}
private static Task HandleExceptionAsync(HttpContext context, Exception exception)
{
var code = HttpStatusCode.InternalServerError;
var errorMsg = string.Empty;
IDictionary <string, string[]> validationErrorMessages = new Dictionary <string, string[]>();
switch (exception)
{
case ValidationException validationException:
code = HttpStatusCode.BadRequest;
validationErrorMessages = validationException.Failures;
break;
case BadRequestException badRequestException:
code = HttpStatusCode.BadRequest;
errorMsg = badRequestException.Message;
break;
case NotFoundException notFoundException:
code = HttpStatusCode.NotFound;
errorMsg = notFoundException.Message;
break;
case UnauthorizedException _:
code = HttpStatusCode.Unauthorized;
break;
}
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)code;
string result;
if (validationErrorMessages.Count == 0)
{
var errorModel = new ErrorModel
{
Title = code.ToString(),
Status = (int)code,
TraceId = context.TraceIdentifier,
Error = errorMsg
};
result = JsonConvert.SerializeObject(errorModel);
}
else
{
var errorModel = new ValidationErrorModel
{
Title = "One or more validation errors occured.",
Status = (int)code,
TraceId = context.TraceIdentifier,
Errors = validationErrorMessages
};
result = JsonConvert.SerializeObject(errorModel);
}
return(context.Response.WriteAsync(result));
}
private static Task HandleValidationExceptionAsync(HttpContext context, DomainValidationException exception)
{
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
var error = new ValidationErrorModel()
{
Errors = exception.Errors.Select(x => new ValidationErrorMessageModel(x.Key, x.Value)).ToList()
};
string data = JsonConvert.SerializeObject(error);
return(context.Response.WriteAsync(data));
}
public void BuildModelFromEntity()
{
var model = new ValidationErrorModel
{
IsWarning = true,
RuleName = "RuleName",
ErrorMessage = "ErrorMessage",
ConRefNumber = "ConRefNumber",
DeliverableCode = "DeliverableCode",
CalendarYear = "CalendarYear",
CalendarMonth = "CalendarMonth",
CostType = "CostType",
ReferenceType = "ReferenceType",
Reference = "Reference",
ULN = "ULN",
ProviderSpecifiedReference = "ProviderSpecifiedReference",
Value = "Value",
LearnAimRef = "LearnAimRef",
SupplementaryDataPanelDate = "SupplementaryDataPanelDate",
};
var expectedModel = new ValidationError
{
Severity = "W",
RuleId = "RuleName",
ErrorMessage = "ErrorMessage",
CreatedOn = new DateTime(2019, 8, 1),
ConRefNumber = "ConRefNumber",
DeliverableCode = "DeliverableCode",
CalendarYear = "CalendarYear",
CalendarMonth = "CalendarMonth",
CostType = "CostType",
ReferenceType = "ReferenceType",
Reference = "Reference",
ULN = "ULN",
ProviderSpecifiedReference = "ProviderSpecifiedReference",
Value = "Value",
LearnAimRef = "LearnAimRef",
SupplementaryDataPanelDate = "SupplementaryDataPanelDate",
SourceFileId = 1
};
NewService().BuildModelFromEntity(model, new DateTime(2019, 8, 1), 1).Should().BeEquivalentTo(expectedModel);
}
public override void OnActionExecuting(ActionExecutingContext context)
{
if (!context.ModelState.IsValid)
{
var validationErrorModel = new ValidationErrorModel(context.ModelState);
// TODO: DI!!!
_logger.LogError("ModelValidation. {0}.", _errorSerializer.JsonSerialize(validationErrorModel));
if (!_showValidationErrors)
{
validationErrorModel.Errors = null;
}
context.Result = new ObjectResult(validationErrorModel)
{
StatusCode = _statusCode
};
}
}
private ValidationErrorModel BuildValidationErrorModel(EasCsvRecord record, string errorCode, ValidationErrorRule validationErrorRule)
{
if (validationErrorRule == null)
{
throw new Exception($"ValidationErrorRule Not found for the error code: {errorCode}");
}
var errorModel = new ValidationErrorModel()
{
FundingLine = record.FundingLine,
AdjustmentType = record.AdjustmentType,
CalendarYear = record.CalendarYear,
CalendarMonth = record.CalendarMonth,
Value = record.Value,
ErrorMessage = validationErrorRule.Message,
RuleName = errorCode,
Severity = validationErrorRule.Severity,
DevolvedAreaSoF = record.DevolvedAreaSourceOfFunding
};
return(errorModel);
}
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
if (!context.ModelState.IsValid)
{
var errorsInModelState = context.ModelState
.Where(x => x.Value.Errors.Count > 0)
.ToDictionary(
kvp => kvp.Key,
kvp => kvp.Value.Errors.Select(x => x.ErrorMessage).ToArray()
);
var errorResponse = new ValidationErrorResponse();
foreach (var error in errorsInModelState)
{
foreach (var subError in error.Value)
{
if (errorResponse.Errors.Exists(x => x.FieldName == error.Key))
{
errorResponse.Errors.Find(x => x.FieldName == error.Key).Errors.Add(subError);
}
else
{
var errorModel = new ValidationErrorModel
{
FieldName = error.Key,
Errors = new List <string>(),
};
errorModel.Errors.Add(subError);
errorResponse.Errors.Add(errorModel);
}
}
}
context.Result = new UnprocessableEntityObjectResult(errorResponse);
return;
}
await next();
}
public ValidationError BuildModelFromEntity(ValidationErrorModel model, DateTime createdOn, int fileId)
{
return(new ValidationError
{
Severity = model.IsWarning ? DataStoreConstants.ErrorSeverity.Warning : DataStoreConstants.ErrorSeverity.Error,
RuleId = model.RuleName,
ErrorMessage = model.ErrorMessage,
CreatedOn = createdOn,
ConRefNumber = model.ConRefNumber,
DeliverableCode = model.DeliverableCode,
CalendarYear = model.CalendarYear,
CalendarMonth = model.CalendarMonth,
CostType = model.CostType,
ReferenceType = model.ReferenceType,
Reference = model.Reference,
ULN = model.ULN,
ProviderSpecifiedReference = model.ProviderSpecifiedReference,
Value = model.Value,
LearnAimRef = model.LearnAimRef,
SupplementaryDataPanelDate = model.SupplementaryDataPanelDate,
SourceFileId = fileId
});
}
private List <ValidationErrorModel> BuildValidationErrorModels(IEnumerable <ValidationError> validationErrors)
{
List <ValidationErrorModel> validationErrorModels = new List <ValidationErrorModel>();
foreach (var error in validationErrors)
{
var model = new ValidationErrorModel
{
AdjustmentType = error.AdjustmentType,
FundingLine = error.FundingLine,
Value = error.Value,
CalendarYear = error.CalendarYear,
ErrorMessage = error.ErrorMessage,
CalendarMonth = error.CalendarMonth,
Severity = error.Severity,
RuleName = error.RuleId,
DevolvedAreaSoF = error.DevolvedAreaSoF
};
validationErrorModels.Add(model);
}
return(validationErrorModels);
}
