added model validation filter

Luticate2.Utils/Controllers/LuCrudController.cs

-using Luticate2.Utils.Dbo.Basic;
+using System.ComponentModel.DataAnnotations;
+using Luticate2.Utils.Dbo.Basic;
 using Luticate2.Utils.Dbo.Filter;
 using Luticate2.Utils.Dbo.OrderBy;
 using Luticate2.Utils.Interfaces;
 
         [HttpGet]
         [Route("[controller]/{id}")]
-        public LuApiWrapperDbo<TDboRead> GetSingleById(TId id)
+        public LuApiWrapperDbo<TDboRead> GetSingleById([Required]TId id)
         {
             return Handle(Busines.GetSingleById(id));
         }
 
         [HttpGet]
         [Route("[controller]")]
-        public LuApiWrapperDbo<LuPaginatedDbo<TDboRead>> GetMultiple(LuOrderByDbo orderBy, LuFilterDbo filter,
+        public LuApiWrapperDbo<LuPaginatedDbo<TDboRead>> GetMultiple([Required]LuOrderByDbo orderBy, LuFilterDbo filter,
             int page = 0, int perPage = int.MaxValue)
         {
             return Handle(Busines.GetMultiple(orderBy, filter, page, perPage));
 
         [HttpPost]
         [Route("[controller]")]
-        public LuApiWrapperDbo<TDboRead> AddDbo([FromBody]TDboCreate data)
+        public LuApiWrapperDbo<TDboRead> AddDbo([FromBody][Required]TDboCreate data)
         {
             return Handle(Busines.AddDbo(data));
         }
 
         [HttpPost]
         [Route("[controller]/{id}")]
-        public LuApiWrapperDbo<TDboRead> EditSingleByIdDbo(TId id, [FromBody]TDboUpdate data)
+        public LuApiWrapperDbo<TDboRead> EditSingleByIdDbo([Required]TId id, [FromBody][Required]TDboUpdate data)
         {
             return Handle(Busines.EditSingleByIdDbo(id, data));
         }
 
         [HttpDelete]
         [Route("[controller]/{id}")]
-        public LuApiWrapperDbo<TDboRead> Delete(TId id)
+        public LuApiWrapperDbo<TDboRead> Delete([Required]TId id)
         {
             return Handle(Busines.DeleteSingleByIdDbo(id));
         }

Luticate2.Utils/Controllers/LuUtilsExtensions.cs

                 {
                     options.ModelBinderProviders.Insert(0, new LuOrderByBinderProvider());
                     options.ModelBinderProviders.Insert(0, new LuFilterBinderProvider());
+                    options.Filters.Add(typeof(LuModelStateFilter));
                 });
             return builder;
         }

Luticate2.Utils/Dbo/OrderBy/LuOrderByBinder.cs

                 data = "";
             }
             data = data.Trim();
-            var dbo = new LuOrderByDbo {Fields = new List<LuOrderByFieldDbo>()};
             if (data != "")
             {
+                var dbo = new LuOrderByDbo {Fields = new List<LuOrderByFieldDbo>()};
                 var fields = data.Split(',');
                 foreach (var field in fields)
                 {
                     }
                     dbo.Fields.Add(value);
                 }
+                return LuResult<LuOrderByDbo>.Ok(dbo);
             }
-            return LuResult<LuOrderByDbo>.Ok(dbo);
+            return LuResult<LuOrderByDbo>.Error(LuStatus.InputError, "Order by is empty or missing", "");
         }
 
         public Task BindModelAsync(ModelBindingContext bindingContext)

Luticate2.Utils/Middlewares/LuModelStateFilter.cs

+using System.ComponentModel.DataAnnotations;
+using System.Linq;
+using System.Reflection;
+using Luticate2.Utils.Controllers;
+using Luticate2.Utils.Dbo.Result;
+using Microsoft.AspNetCore.Mvc.Controllers;
+using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+
+namespace Luticate2.Utils.Middlewares
+{
+    public class LuModelStateFilter : IActionFilter
+    {
+        public void OnActionExecuting(ActionExecutingContext context)
+        {
+            var descriptor = context.ActionDescriptor as ControllerActionDescriptor;
+
+            if (descriptor != null)
+            {
+                var parameters = descriptor.MethodInfo.GetParameters();
+
+                foreach (var parameter in parameters)
+                {
+                    var argument = context.ActionArguments.ContainsKey(parameter.Name) ? context.ActionArguments[parameter.Name] : null;
+
+                    EvaluateValidationAttributes(parameter, argument, context.ModelState);
+                }
+            }
+
+            if (!context.ModelState.IsValid)
+            {
+                var errors = "";
+                foreach (var key in context.ModelState.Keys)
+                {
+                    var error = " " + key + ": " + context.ModelState[key]
+                        .Errors.Select(modelError => modelError.ErrorMessage)
+                        .Aggregate((s, s1) => s + ", " + s1);
+                    errors += error;
+                }
+                throw new LuResultException(LuResult<object>.Error(LuStatus.InputError, "Validation error:" + errors, ""));
+            }
+        }
+
+        private void EvaluateValidationAttributes(ParameterInfo parameter, object argument, ModelStateDictionary modelState)
+        {
+            foreach (var attributeData in parameter.CustomAttributes)
+            {
+                var validationAttribute = parameter.GetCustomAttribute(attributeData.AttributeType) as ValidationAttribute;
+
+                if (validationAttribute != null)
+                {
+                    var isValid = validationAttribute.IsValid(argument);
+                    if (!isValid)
+                    {
+                        modelState.AddModelError(parameter.Name, validationAttribute.FormatErrorMessage(parameter.Name));
+                    }
+                }
+            }
+        }
+
+        public void OnActionExecuted(ActionExecutedContext context)
+        {
+
+        }
+    }
+}

TestUtils/Binders/LuOrderByBinderTest.cs

         {
             var res = LuOrderByBinder.FromString("");
             Assert.NotNull(res);
-            Assert.Equal(LuStatus.Success, res.Status);
-            var dbo = res.Data;
-            Assert.NotNull(dbo);
-            Assert.NotNull(dbo.Fields);
-            Assert.Equal(0, dbo.Fields.Count);
+            Assert.Equal(LuStatus.InputError, res.Status);
         }
 
         [Fact]

WebApiUtils/Startup.cs

 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using TestUtils;
 using TestUtils.DataAccess;
 using WebApiUtils.Business;
 
             // Add framework services.
             services.AddApplicationInsightsTelemetry(Configuration);
 
-            services.AddLuticateUtils(options => options.Version = "sdev");
+            services.AddLuticateUtils(options => options.Version = "dev");
 
             services.AddTransient<PkGuidBusiness>();
             services.AddTransient<LuUtilsPkGuidDataAccess>();