Refatorando tratamento de erros

Validador.API/Models/ValidadorModel.cs

@@ -1,5 +1,5 @@
 using Microsoft.AspNetCore.Mvc.Rendering;
-using Validador.Application.Schemas;
+using Validador.Application.Errors;
 
 namespace Validador.API.Models
 {

Validador.API/Views/Validador/Index.cshtml

@@ -88,7 +88,7 @@
                                             </td>
                                             <td>
                                                 <div class='small text-muted'>
-                                                    @Html.DisplayFor(modelItem => validationError.Message)
+                                                    @Html.DisplayFor(modelItem => validationError.ValidationMessage)
                                                 </div>
                                             </td>
                                         </tr>

Validador.Application/Collections/Collection.cs

@@ -1,8 +1,7 @@
 using System.Reflection;
 using System.Xml;
-using System.Xml.Linq;
 using System.Xml.Schema;
-using Validador.Application.Schemas;
+using Validador.Application.Errors;
 
 namespace Validador.Application
 {
@@ -42,16 +41,14 @@ public List<ValidationError> ValidateSchema(string xmlString)
             settings.ValidationEventHandler += new ValidationEventHandler(ValidationEventHandler);
 
             XmlReader reader = XmlReader.Create(new StringReader(xmlString), settings);
-            while (reader.Read());
+            while (reader.Read()) ;
             return ValidationErrors;
         }
 
         private void ValidationEventHandler(object sender, ValidationEventArgs args)
         {
-            if (args.Severity == XmlSeverityType.Warning)
-                ValidationErrors.Add(new ValidationError(args.Message, ValidationError.Severity.Warning));
-            else
-                ValidationErrors.Add(new ValidationError(args.Message, ValidationError.Severity.Error));
+            ValidationError error = ErrorFactory.Create(args.Message);
+            ValidationErrors.Add(error);
         }
 
         protected abstract void SetSchemas();

Validador.Application/Errors/ErrorFactory.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+
+namespace Validador.Application.Errors
+{
+    public static class ErrorFactory
+    {
+        public static ValidationError Create(string errorMessage)
+        {
+            switch (errorMessage)
+            {
+                default:
+                    return new GenericValidationError(errorMessage);
+                case var messagem when new Regex(@"The Pattern constraint failed").IsMatch(messagem):
+                    return new PatternConstraintFailed(errorMessage);
+                case var messagem when new Regex(@"List of possible elements expected").IsMatch(messagem):
+                    return new InvalidChildElement(errorMessage);
+            }
+        }
+    }
+
+
+}

Validador.Application/Errors/GenericValidationError.cs

@@ -0,0 +1,17 @@
+using System.Xml.Schema;
+
+namespace Validador.Application.Errors
+{
+    public class GenericValidationError : ValidationError
+    {
+        public GenericValidationError(string message) : base(message)
+        {
+            SeverityType = XmlSeverityType.Warning;
+        }
+
+        public override string CreateValidationMessage()
+        {
+            return string.Format("Erro de validação: '{0}'", Message);
+        }
+    }
+}

Validador.Application/Errors/InvalidChildElement.cs

@@ -0,0 +1,20 @@
+using System.Text.RegularExpressions;
+using System.Xml.Schema;
+
+namespace Validador.Application.Errors
+{
+    public class InvalidChildElement : ValidationError
+    {
+        public InvalidChildElement(string message) : base(message) {
+            SeverityType = XmlSeverityType.Error;
+        }
+
+        public const string Pattern = @"element '(\w+)'.*element '(\w+)'.*expected: '(\w+)'";
+
+        public override string CreateValidationMessage()
+        {
+            Match match = new Regex(Pattern).Match(Message);
+            return string.Format("O elemento '{0}' possui elemento filho inválido: '{1}'. Era esperado o elemento: '{2}'", match.Groups[1].Value, match.Groups[2].Value, match.Groups[3].Value);
+        }
+    }
+}

Validador.Application/Errors/PatternConstraintFailed.cs

@@ -0,0 +1,20 @@
+using System.Text.RegularExpressions;
+using System.Xml.Schema;
+
+namespace Validador.Application.Errors
+{
+    public class PatternConstraintFailed : ValidationError
+    {
+        public PatternConstraintFailed(string message) : base(message) {
+            SeverityType = XmlSeverityType.Error;
+        }
+
+        public const string Pattern = @"'(.+)'.*'(.+)'.*'(.+)'";
+
+        public override string CreateValidationMessage()
+        {
+            Match match = new Regex(Pattern).Match(Message);
+            return string.Format("O elemento '{0}' é inválido. O valor '{1}' não está de acordo com os tipos definidos em: {2}'", match.Groups[1].Value, match.Groups[2].Value, match.Groups[3].Value);
+        }
+    }
+}

Validador.Application/Errors/ValidationError.cs

@@ -0,0 +1,22 @@
+using System.Xml.Schema;
+
+namespace Validador.Application.Errors
+{
+    public abstract class ValidationError : Exception
+    {
+        public ValidationError(string message) : base(message)
+        {
+        }
+        public string ValidationMessage
+        {
+            get
+            {
+                return CreateValidationMessage();
+            }
+        }
+
+        public abstract string CreateValidationMessage();
+        public XmlSeverityType SeverityType { get; set; }
+    }
+}
+