improved LuFilterDbo

Luticate2.Utils/Dbo/Filter/LuFilterBinder.cs

@@ -1,4 +1,6 @@
-using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
 using Luticate2.Utils.Dbo.Result;
 using Microsoft.AspNetCore.Mvc.ModelBinding;
 
@@ -6,16 +8,38 @@ namespace Luticate2.Utils.Dbo.Filter
 {
     public class LuFilterBinder : IModelBinder
     {
+        private const string RegExp = "^([\\w\\-]+) *: *([^ \"\']+|\"[^\"]+\"|\'[^\']+\') *";
+
         public static LuResult<LuFilterDbo> FromString(string data)
         {
             if (data == null)
             {
                 data = "";
             }
-            data = data.Trim();
+            var filters = new Dictionary<string, string>();
+
+            Match match;
+            do
+            {
+                match = Regex.Match(data, RegExp);
+                if (match.Success)
+                {
+                    var value = match.Groups[2].Value;
+                    if ((value.StartsWith("\"") && value.EndsWith("\"")) ||
+                        (value.StartsWith("\'") && value.EndsWith("\'")))
+                    {
+                        value = value.Remove(value.Length - 1, 1).Remove(0, 1);
+                    }
+                    filters.Add(match.Groups[1].Value, value);
+                    data = data.Remove(match.Index, match.Length);
+                }
+            } while (match.Success);
+
+
             var dbo = new LuFilterDbo
             {
-                Query = data
+                Query = data.Trim(),
+                Filters = filters
             };
             return LuResult<LuFilterDbo>.Ok(dbo);
         }

Luticate2.Utils/Dbo/Filter/LuFilterDbo.cs

@@ -1,7 +1,54 @@
-namespace Luticate2.Utils.Dbo.Filter
+using System.Collections.Generic;
+
+namespace Luticate2.Utils.Dbo.Filter
 {
     public class LuFilterDbo
     {
         public string Query { get; set; }
+
+        public IDictionary<string, string> Filters { get; set; }
+
+        public string GetFilterString(string key, string defaultValue)
+        {
+            if (!Filters.ContainsKey(key))
+            {
+                return defaultValue;
+            }
+            return Filters[key];
+        }
+
+        public bool GetFilterBool(string key, bool defaultValue)
+        {
+            var value = GetFilterString(key, "").ToLower();
+            if (value == "true")
+            {
+                return true;
+            }
+            if (value == "false")
+            {
+                return false;
+            }
+            return defaultValue;
+        }
+
+        public int GetFilterInt(string key, int defaultValue)
+        {
+            int v;
+            if (int.TryParse(GetFilterString(key, ""), out v))
+            {
+                return v;
+            }
+            return defaultValue;
+        }
+
+        public double GetFilterFloat(string key, double defaultValue)
+        {
+            double v;
+            if (double.TryParse(GetFilterString(key, ""), out v))
+            {
+                return v;
+            }
+            return defaultValue;
+        }
     }
 }

TestUtils/Binders/LuFilterBinderTest.cs

@@ -0,0 +1,208 @@
+using System.Collections.Generic;
+using Luticate2.Utils.Dbo.Filter;
+using Luticate2.Utils.Dbo.Result;
+using Xunit;
+
+namespace TestUtils.Binders
+{
+    public class LuFilterBinderTest
+    {
+        [Fact]
+        public void Test1()
+        {
+            var res = LuFilterBinder.FromString("");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>(), res.Data.Filters);
+        }
+
+        [Fact]
+        public void Test2()
+        {
+            var res = LuFilterBinder.FromString("test");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("test", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>(), res.Data.Filters);
+        }
+
+        [Fact]
+        public void Test3()
+        {
+            var res = LuFilterBinder.FromString(" Test.42 24 ");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("Test.42 24", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>(), res.Data.Filters);
+        }
+
+        [Fact]
+        public void Test4()
+        {
+            var res = LuFilterBinder.FromString(" test: 42");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("test: 42", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>(), res.Data.Filters);
+        }
+
+        [Fact]
+        public void Test5()
+        {
+            var res = LuFilterBinder.FromString("test: 42");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>{{"test", "42"}}, res.Data.Filters);
+        }
+
+        [Fact]
+        public void Test6()
+        {
+            var res = LuFilterBinder.FromString("test: 42 a filter value");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("a filter value", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>{{"test", "42"}}, res.Data.Filters);
+        }
+
+        [Fact]
+        public void Test7()
+        {
+            var res = LuFilterBinder.FromString("test: \"42 a filter value\"");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>{{"test", "42 a filter value"}}, res.Data.Filters);
+        }
+
+        [Fact]
+        public void Test8()
+        {
+            var res = LuFilterBinder.FromString("test: \'42 a filter value\'");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>{{"test", "42 a filter value"}}, res.Data.Filters);
+        }
+
+        [Fact]
+        public void Test9()
+        {
+            var res = LuFilterBinder.FromString("test: \'42 a filter value\' some text");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("some text", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>{{"test", "42 a filter value"}}, res.Data.Filters);
+        }
+
+        [Fact]
+        public void Test10()
+        {
+            var res = LuFilterBinder.FromString("test: \'42 a filter value\' test-2 : \'another value\' some text");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("some text", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>
+            {
+                {"test", "42 a filter value"},
+                {"test-2", "another value"}
+            }, res.Data.Filters);
+        }
+
+        [Fact]
+        public void TestBool()
+        {
+            var res = LuFilterBinder.FromString("test: true test-2 : \'false\' fail: 42 some text");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("some text", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>
+            {
+                {"test", "true"},
+                {"test-2", "false"},
+                {"fail", "42"}
+            }, res.Data.Filters);
+            Assert.True(res.Data.GetFilterBool("test", false));
+            Assert.True(res.Data.GetFilterBool("test", true));
+            Assert.False(res.Data.GetFilterBool("test-2", false));
+            Assert.False(res.Data.GetFilterBool("test-2", true));
+            Assert.False(res.Data.GetFilterBool("fail", false));
+            Assert.True(res.Data.GetFilterBool("fail", true));
+            Assert.False(res.Data.GetFilterBool("nx", false));
+            Assert.True(res.Data.GetFilterBool("nx", true));
+        }
+
+        [Fact]
+        public void TestString()
+        {
+            var res = LuFilterBinder.FromString("test: 42 test-2 : \'24\' fail: test some text");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("some text", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>
+            {
+                {"test", "42"},
+                {"test-2", "24"},
+                {"fail", "test"}
+            }, res.Data.Filters);
+            Assert.Equal("42", res.Data.GetFilterString("test", ""));
+            Assert.Equal("24", res.Data.GetFilterString("test-2", ""));
+            Assert.Equal("test", res.Data.GetFilterString("fail", "azerty"));
+            Assert.Equal("qwerty", res.Data.GetFilterString("nx", "qwerty"));
+        }
+
+        [Fact]
+        public void TestInt()
+        {
+            var res = LuFilterBinder.FromString("test: 42 test-2 : \'24\' fail: test some text");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("some text", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>
+            {
+                {"test", "42"},
+                {"test-2", "24"},
+                {"fail", "test"}
+            }, res.Data.Filters);
+            Assert.Equal(42, res.Data.GetFilterInt("test", 0));
+            Assert.Equal(24, res.Data.GetFilterInt("test-2", 0));
+            Assert.Equal(2424, res.Data.GetFilterInt("fail", 2424));
+            Assert.Equal(4242, res.Data.GetFilterInt("nx", 4242));
+        }
+
+        [Fact]
+        public void TestFloat()
+        {
+            var res = LuFilterBinder.FromString("test: 42.24 test-2 : \'24.42\' fail:test some text");
+            Assert.NotNull(res);
+            Assert.NotNull(res.Data);
+            Assert.Equal(LuStatus.Success, res.Status);
+            Assert.Equal("some text", res.Data.Query);
+            Assert.Equal(new Dictionary<string, string>
+            {
+                {"test", "42.24"},
+                {"test-2", "24.42"},
+                {"fail", "test"}
+            }, res.Data.Filters);
+            Assert.Equal(42.24, res.Data.GetFilterFloat("test", 0));
+            Assert.Equal(24.42, res.Data.GetFilterFloat("test-2", 0));
+            Assert.Equal(2424.4242, res.Data.GetFilterFloat("fail", 2424.4242));
+            Assert.Equal(4242.2424, res.Data.GetFilterFloat("nx", 4242.2424));
+        }
+    }
+}