private static Task HandleModelValidationExceptionAsync(HttpContext context, ModelValidationException resultException)
{
context.Response.ContentType = "application/json";
context.Response.StatusCode = resultException.StatusCode;
return(context.Response.WriteAsync(JsonConvert.SerializeObject(new ApiResponse(false,
resultException.ErrorMessage, null, resultException.ErrorData))));
}
public static void AddModelError(this ModelStateDictionary modelState, ModelValidationException modelValidationException)
{
if (modelValidationException == null)
{
throw new ArgumentNullException("modelValidationException cannot be null.");
}
modelState.AddModelError(modelValidationException.ValidationResult);
}
public override async Task OnActionExecutingAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
{
if (actionContext.ModelState.IsValid == false)
{
var exception = new ModelValidationException(actionContext.ModelState);
var developerName = ExceptionHandlerUtilities.GetDeveloperName(actionContext.Request);
actionContext.Response = await ExceptionHandlerUtilities.ReportExceptionAndCreateResponseAsync(actionContext.Request, exception, developerName);
}
}
public void Should_keep_validation_errors()
{
List <ValidationResult> validationResults = new List <ValidationResult>();
ModelValidationException ex = new ModelValidationException(validationResults);
ModelValidationErrorResponse er = new ModelValidationErrorResponse();
er.FillFromException(ex);
Assert.Equal(validationResults, er.ValidationErrors);
}
public void String_and_inner_Ctor_creates_empty_exception()
{
CodeGenerator.IsValidLanguageIndependentIdentifier("d");
var inner = new InvalidOperationException();
var e = new ModelValidationException("A", inner);
Assert.Equal("A", e.Message);
Assert.Equal(inner, e.InnerException);
}
private static string GetMessage(ModelValidationException ex)
{
var errors = new StringBuilder();
errors.AppendLine();
#if DEBUG
errors.AppendLine($"[{ex.GetType().Name}]");
#endif
errors.AppendLine($"داده های ارسالی به ساختار داده ای نامعتبر می باشد");
return(errors.ToString());
}
public void Can_create_exception_with_errors()
{
var modelValidationException
= new ModelValidationException(
new[]
{
(new DataModelErrorEventArgs
{
ErrorMessage = "Foo"
})
});
Assert.True(modelValidationException.Message.Contains("Foo"));
}
public void Should_serializate_correctly()
{
ModelValidationException ex = new ModelValidationException(ValidationResults);
// Save the full ToString() value, including the exception message and stack trace.
string exceptionToString = ex.ToString();
string serializedData = JsonSerializer.Serialize(ex);
ex = JsonSerializer.Deserialize <ModelValidationException>(serializedData);
// Make sure custom properties are preserved after serialization
Assert.Equal(Message, ex.Message);
Assert.Equal(2, ex.ValidationErrors.Count);
Assert.Equal(Error1.ErrorMessage, ex.ValidationErrors[0].ErrorMessage);
Assert.Equal(Error2.ErrorMessage, ex.ValidationErrors[1].ErrorMessage);
// Double-check that the exception message and stack trace (owned by the base Exception) are preserved
Assert.Equal(exceptionToString, ex.ToString());
}
public void OnActionExecuting(ActionExecutingContext context)
{
if (!context.ModelState.IsValid)
{
var apiException = new ModelValidationException();
foreach (var modelStateKey in context.ModelState.Keys)
{
var modelStateVal = context.ModelState[modelStateKey];
var validationExceptions = new ApiValidationError()
{
Key = modelStateKey,
Values = modelStateVal.Errors.Select(x => x.ErrorMessage).ToArray(),
};
apiException.apiValidationErrors.Add(validationExceptions);
}
throw apiException;
}
}
static public IList <string> diagramValidation(EA.Repository Repository, EA.Diagram diagram)
{
JSchema jschema = null;
JObject json = null;
String classifier = null;
try
{
//logger.log("Validate Sample");
Hashtable h = sampleToJObject(Repository, diagram);
json = (JObject)h["json"];
classifier = (String)h["class"];
//logger.log("JObject formed");
EA.Package samplePkg = Repository.GetPackageByID(diagram.PackageID);
EA.Package samplesPackage = Repository.GetPackageByID(samplePkg.ParentID);
EA.Package apiPackage = Repository.GetPackageByID(samplesPackage.ParentID);
EA.Package schemaPackage = null;
foreach (EA.Package p in apiPackage.Packages)
{
if (p != null && p.Name.Equals(APIAddinClass.API_PACKAGE_SCHEMAS))
{
schemaPackage = p;
}
}
if (schemaPackage == null)
{
throw new Exception("No Schemas package found");
}
EA.Diagram schemaDiagram = null;
foreach (EA.Diagram d in schemaPackage.Diagrams)
{
if (d.Stereotype != null && d.Stereotype.Equals(APIAddinClass.EA_STEREOTYPE_SCHEMADIAGRAM))
{
logger.log("Checking diagram root:" + d.Name);
Hashtable ht = SchemaManager.schemaDiagramRoot(Repository, d);
EA.Element rootElement = (EA.Element)ht["class"];
logger.log("Comparing diagram root" + rootElement.Name + " equals " + classifier);
if (rootElement.Name == classifier)
{
logger.log("Found corresponding schema diagram:" + d.Name);
schemaDiagram = d;
break;
}
}
}
if (schemaDiagram == null)
{
ModelValidationException mex = new ModelValidationException("Invalid Sample or Schema");
mex.errors.messages.Add("There is no schema with a root classifier of:" + classifier);
throw mex;
}
jschema = SchemaManager.schemaToJsonSchema(Repository, schemaDiagram).Value;
}
catch (ModelValidationException ex)
{
return(ex.errors.messages);
}
IList <string> messages;
if (!json.IsValid(jschema, out messages))
{
logger.log("Sample is not valid:");
return(messages);
}
else
{
logger.log("Sample is Valid!");
return(null);
}
}
public void String_Ctor_creates_empty_exception()
{
var e = new ModelValidationException("A");
Assert.Equal("A", e.Message);
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="ex"></param>
/// <returns></returns>
public static string Get(this HttpContext context, Exception ex)
{
var responseModel = new ApiResponse();
try
{
context.Response.StatusCode = (int)HttpStatusCode.OK;
if (ex.GetType() == typeof(SecurityTokenValidationException))
{
responseModel.Message = "Invalid token";
responseModel.Status = ApplicationStatusCode.InvalidToken;
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (ex.GetType() == typeof(SecurityTokenInvalidIssuerException))
{
responseModel.Message = "Invalid issuer";
responseModel.Status = ApplicationStatusCode.InvalidIssuer;
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (ex.GetType() == typeof(SecurityTokenExpiredException))
{
responseModel.Message = "Token expired";
responseModel.Status = ApplicationStatusCode.TokenExpired;
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (ex.GetType() == typeof(ModelValidationException))
{
ModelValidationException?error = ex as ModelValidationException;
responseModel.Status = ApplicationStatusCode.ModelValidation;
responseModel.Message = ex.Message;
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (ex.GetType() == typeof(ArgumentNullException))
{
ModelValidationException error = ex as ModelValidationException;
responseModel.Status = ApplicationStatusCode.ModelValidation;
responseModel.Message = "Parameter passed is incorrect.";
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (ex.GetType() == typeof(AlreadyExistException))
{
responseModel.Status = ApplicationStatusCode.AlreadyExist;
responseModel.Message = ex.Message;
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (ex.GetType() == typeof(NotFoundException))
{
responseModel.Status = ApplicationStatusCode.NotFound;
responseModel.Message = ex.Message;
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
}
else if (ex.GetType() == typeof(NotActiveException))
{
responseModel.Status = ApplicationStatusCode.NotActive;
responseModel.Message = ex.Message;
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (ex.GetType() == typeof(BadRequestException))
{
responseModel.Status = ApplicationStatusCode.BadRequest;
responseModel.Message = ex.Message;
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (ex.GetType() == typeof(VerificationCodeException))
{
responseModel.Status = ApplicationStatusCode.VerificationCode;
responseModel.Message = ex.Message;
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (ex.GetType() == typeof(PasswordException))
{
responseModel.Status = ApplicationStatusCode.PasswordError;
responseModel.Message = ex.Message;
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (ex.GetType() == typeof(SessionExpiredException))
{
responseModel.Status = ApplicationStatusCode.SessionExpired;
responseModel.Message = ex.Message;
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (ex.GetType() == typeof(InvalidOperationException))
{
responseModel.Status = ApplicationStatusCode.InvalidOperation;
responseModel.Message = ex.Message; // "Invalid Request";
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else if (ex.GetType() == typeof(LoginException))
{
responseModel.Status = ApplicationStatusCode.LoginOperation;
responseModel.Message = ex.Message;
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
else
{
responseModel.Status = ApplicationStatusCode.GenericError;
responseModel.Message = ex.Message;
context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
}
return(JsonConvert.SerializeObject(responseModel));
}
catch (Exception _ex)
{
responseModel.Status = ApplicationStatusCode.GenericError;
responseModel.Message = _ex.Message != null ? _ex.Message : "Please contact the administrator";
return(JsonConvert.SerializeObject(responseModel));
}
}
