Merge pull request #762 from MrZoidberg/issue-761-DataObjectSerializer-refactoring

danielgerlag · web-flow · commit 87d52b74c1da · 2021-02-13T16:54:02.000-08:00
Refactored DataObjectSerializer to be able to use decimal value types and BsonRepresentation attributes
diff --git a/src/providers/WorkflowCore.Persistence.MongoDB/README.md b/src/providers/WorkflowCore.Persistence.MongoDB/README.md
@@ -17,3 +17,35 @@ Use the .UseMongoDB extension method when building your service provider.
 ```C#
 services.AddWorkflow(x => x.UseMongoDB(@"mongodb://localhost:27017", "workflow"));
 ```
+
+### State object serialization
+
+By default (to maintain backwards compatibility), the state object is serialized using a two step serialization process using object -> JSON -> BSON serialization.
+This approach has some limitations, for example you cannot control which types will be used in MongoDB for particular fields and you cannot use basic types that are not present in JSON (decimal, timestamp, etc).
+
+To eliminate these limitations, you can use a direct object -> BSON serialization and utilize all serialization possibilities that MongoDb driver provides. You can read more in the [MongoDb CSharp documentation](https://mongodb.github.io/mongo-csharp-driver/1.11/serialization/).
+To enable direct serilization you need to register a class map for you state class somewhere in your startup process before you run `WorkflowHost`.
+
+```C#
+private void RunWorkflow()
+{
+    var host = this._serviceProvider.GetService<IWorkflowHost>();
+    if (host == null)
+    {
+        return;
+    }
+
+    if (!BsonClassMap.IsClassMapRegistered(typeof(MyWorkflowState)))
+    {
+        BsonClassMap.RegisterClassMap<MyWorkflowState>(cm =>
+        {
+            cm.AutoMap();
+        });
+    }
+
+    host.RegisterWorkflow<MyWorkflow, MyWorkflowState>();
+
+    host.Start();
+}
+
+```
diff --git a/src/providers/WorkflowCore.Persistence.MongoDB/Services/DataObjectSerializer.cs b/src/providers/WorkflowCore.Persistence.MongoDB/Services/DataObjectSerializer.cs
@@ -2,11 +2,9 @@
 using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Bson;
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using System.Linq.Expressions;
-using System.Threading.Tasks;
-using WorkflowCore.Models;
 using Newtonsoft.Json;
 
 namespace WorkflowCore.Persistence.MongoDB.Services
@@ -17,7 +15,7 @@ public class DataObjectSerializer : SerializerBase<object>
         {
             TypeNameHandling = TypeNameHandling.Objects,
         };
-        
+
         public override object Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
         {
             if (context.Reader.CurrentBsonType == BsonType.String)
@@ -26,18 +24,103 @@ public override object Deserialize(BsonDeserializationContext context, BsonDeser
                 return JsonConvert.DeserializeObject(raw, SerializerSettings);
             }
 
-            return BsonSerializer.Deserialize(context.Reader, typeof(object));
+            var obj = BsonSerializer.Deserialize(context.Reader, typeof(object));
+            return obj;
         }
 
         public override void Serialize(BsonSerializationContext context, BsonSerializationArgs args, object value)
         {
-            var str = JsonConvert.SerializeObject(value, SerializerSettings);
-            var doc = BsonDocument.Parse(str);
-            ConvertMetaFormat(doc);
+            BsonDocument doc;
+            if (BsonClassMap.IsClassMapRegistered(value.GetType()))
+            {
+                doc = value.ToBsonDocument();
+                doc.Remove("_t");
+                doc.InsertAt(0, new BsonElement("_t", value.GetType().AssemblyQualifiedName));
+                AddTypeInformation(doc.Elements, value, string.Empty);
+            }
+            else
+            {
+                var str = JsonConvert.SerializeObject(value, SerializerSettings);
+                doc = BsonDocument.Parse(str);
+                ConvertMetaFormat(doc);
+            }
             
             BsonSerializer.Serialize(context.Writer, doc);
         }
 
+        private void AddTypeInformation(IEnumerable<BsonElement> elements, object value, string xPath)
+        {
+            foreach (var element in elements)
+            {
+                var elementXPath = string.IsNullOrEmpty(xPath) ? element.Name : xPath + "." + element.Name;
+                if (element.Value.IsBsonDocument)
+                {
+                    var doc = element.Value.AsBsonDocument;
+                    doc.Remove("_t");
+                    doc.InsertAt(0, new BsonElement("_t", GetTypeNameFromXPath(value, elementXPath)));
+                    AddTypeInformation(doc.Elements, value, elementXPath);
+                }
+                if (element.Value.IsBsonArray)
+                {
+                    AddTypeInformation(element.Value.AsBsonArray, value, elementXPath);
+                }
+            }
+        }
+
+        private string GetTypeNameFromXPath(object root, string xPath)
+        {
+            var parts = xPath.Split('.').ToList();
+            object value = root;
+            while (parts.Count > 0)
+            {
+                var subPath = parts[0];
+                if (subPath[0] == '[')
+                {
+                    var index = Int32.Parse(subPath.Trim('[', ']'));
+                    if ((value is IList) || value.GetType().IsArray)
+                    {
+                        IList list = (IList) value;
+                        value = list[index];
+                    }
+                    else
+                    {
+                        throw new NotSupportedException();
+                    }
+                }
+                else
+                {
+                    var propInfo = value.GetType().GetProperty(subPath);
+                    value = propInfo.GetValue(value);
+                }
+
+                parts.RemoveAt(0);
+            }
+
+            return value.GetType().AssemblyQualifiedName;
+        }
+
+        private void AddTypeInformation(IEnumerable<BsonValue> elements, object value, string xPath)
+        {
+            //foreach (var element in elements) 
+            for (int i = 0; i < elements.Count(); i++)
+            {
+                var element = elements.ElementAt(i);
+                if (element.IsBsonDocument)
+                {
+                    var doc = element.AsBsonDocument;
+                    var elementXPath = xPath + $".[{i}]";
+                    doc.Remove("_t");
+                    doc.InsertAt(0, new BsonElement("_t", GetTypeNameFromXPath(value, elementXPath)));
+                    AddTypeInformation(doc.Elements, value, elementXPath);
+                }
+
+                if (element.IsBsonArray)
+                {
+                    AddTypeInformation(element.AsBsonArray, value, xPath);
+                }
+            }
+        }
+
         private static void ConvertMetaFormat(BsonDocument root)
         {
             var stack = new Stack<BsonDocument>();
@@ -72,4 +155,4 @@ private static void ConvertMetaFormat(BsonDocument root)
             }
         }
     }
-}
+}
diff --git a/src/providers/WorkflowCore.Persistence.MongoDB/WorkflowCore.Persistence.MongoDB.csproj b/src/providers/WorkflowCore.Persistence.MongoDB/WorkflowCore.Persistence.MongoDB.csproj
@@ -14,11 +14,11 @@
     <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
     <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
     <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
-    <Version>3.0.3</Version>
+    <Version>3.0.4</Version>
     <Description>Provides support to persist workflows running on Workflow Core to a MongoDB database.</Description>
-    <AssemblyVersion>3.0.3.0</AssemblyVersion>
-    <FileVersion>3.0.3.0</FileVersion>
-    <PackageVersion>3.0.3</PackageVersion>
+    <AssemblyVersion>3.0.4.0</AssemblyVersion>
+    <FileVersion>3.0.4.0</FileVersion>
+    <PackageVersion>3.0.4</PackageVersion>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/src/samples/WorkflowCore.TestSample01/NUnitTest.cs b/src/samples/WorkflowCore.TestSample01/NUnitTest.cs
@@ -13,9 +13,9 @@ namespace WorkflowCore.TestSample01
     public class NUnitTest : WorkflowTest<MyWorkflow, MyDataClass>
     {
         [SetUp]
-        protected override void Setup()
+        protected override void Setup(bool registerClassMap = false)
         {
-            base.Setup();
+            base.Setup(registerClassMap);
         }
 
         [Test]
diff --git a/test/WorkflowCore.IntegrationTests/Scenarios/DataIOScenario.cs b/test/WorkflowCore.IntegrationTests/Scenarios/DataIOScenario.cs
@@ -29,6 +29,14 @@ public class MyDataClass
             public int Value1 { get; set; }
             public int Value2 { get; set; }
             public int Value3 { get; set; }
+            public decimal Value4 { get; set; }
+            
+            public DataSubclass SubValue { get; set; }
+        }
+
+        public class DataSubclass
+        {
+            public decimal Value5 { get; set; }
         }
 
         public class DataIOWorkflow : IWorkflow<MyDataClass>
@@ -47,18 +55,20 @@ public void Build(IWorkflowBuilder<MyDataClass> builder)
 
         public DataIOScenario()
         {
-            Setup();
+            Setup(true);
         }
 
         [Fact]
         public void Scenario()
         {
-            var workflowId = StartWorkflow(new MyDataClass() { Value1 = 2, Value2 = 3 });
+            decimal v4 = 1.235465673450897890m;
+            var workflowId = StartWorkflow(new MyDataClass() {Value1 = 2, Value2 = 3, Value4 = v4, SubValue = new DataSubclass() {Value5 = v4}});
             WaitForWorkflowToComplete(workflowId, TimeSpan.FromSeconds(30));
 
             GetStatus(workflowId).Should().Be(WorkflowStatus.Complete);
             UnhandledStepErrors.Count.Should().Be(0);
             GetData(workflowId).Value3.Should().Be(5);
+            GetData(workflowId).Value4.Should().Be(v4);
         }
     }
 }
diff --git a/test/WorkflowCore.Testing/WorkflowCore.Testing.csproj b/test/WorkflowCore.Testing/WorkflowCore.Testing.csproj
@@ -12,6 +12,7 @@
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="3.1.0" />
     <PackageReference Include="Microsoft.Extensions.Logging" Version="3.1.0" />
+    <PackageReference Include="MongoDB.Bson" Version="2.8.1" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/WorkflowCore.Testing/WorkflowTest.cs b/test/WorkflowCore.Testing/WorkflowTest.cs
@@ -7,6 +7,7 @@
 using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using MongoDB.Bson.Serialization;
 using WorkflowCore.Interface;
 using WorkflowCore.Models;
 
@@ -20,7 +21,7 @@ public abstract class WorkflowTest<TWorkflow, TData> : IDisposable
         protected IPersistenceProvider PersistenceProvider;
         protected List<StepError> UnhandledStepErrors = new List<StepError>();
 
-        protected virtual void Setup()
+        protected virtual void Setup(bool registerClassMap = false)
         {
             //setup dependency injection
             IServiceCollection services = new ServiceCollection();
@@ -33,6 +34,11 @@ protected virtual void Setup()
             var loggerFactory = serviceProvider.GetService<ILoggerFactory>();
             //loggerFactory.AddConsole(LogLevel.Debug);
 
+            if (registerClassMap && !BsonClassMap.IsClassMapRegistered(typeof(TData)))
+            {
+                BsonClassMap.RegisterClassMap<TData>(map => map.AutoMap());
+            }
+
             PersistenceProvider = serviceProvider.GetService<IPersistenceProvider>();
             Host = serviceProvider.GetService<IWorkflowHost>();
             Host.RegisterWorkflow<TWorkflow, TData>();

Original file line number	Diff line number	Diff line change
`@@ -13,9 +13,9 @@ namespace WorkflowCore.TestSample01`
`13`	`13`	`public class NUnitTest : WorkflowTest<MyWorkflow, MyDataClass>`
`14`	`14`	`{`
`15`	`15`	`[SetUp]`
`16`		`- protected override void Setup()`
	`16`	`+ protected override void Setup(bool registerClassMap = false)`
`17`	`17`	`{`
`18`		`- base.Setup();`
	`18`	`+ base.Setup(registerClassMap);`
`19`	`19`	`}`
`20`	`20`
`21`	`21`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,14 @@ public class MyDataClass`
`29`	`29`	`public int Value1 { get; set; }`
`30`	`30`	`public int Value2 { get; set; }`
`31`	`31`	`public int Value3 { get; set; }`
	`32`	`+ public decimal Value4 { get; set; }`
	`33`	`+`
	`34`	`+ public DataSubclass SubValue { get; set; }`
	`35`	`+ }`
	`36`	`+`
	`37`	`+ public class DataSubclass`
	`38`	`+ {`
	`39`	`+ public decimal Value5 { get; set; }`
`32`	`40`	`}`
`33`	`41`
`34`	`42`	`public class DataIOWorkflow : IWorkflow<MyDataClass>`
`@@ -47,18 +55,20 @@ public void Build(IWorkflowBuilder<MyDataClass> builder)`
`47`	`55`
`48`	`56`	`public DataIOScenario()`
`49`	`57`	`{`
`50`		`- Setup();`
	`58`	`+ Setup(true);`
`51`	`59`	`}`
`52`	`60`
`53`	`61`	`[Fact]`
`54`	`62`	`public void Scenario()`
`55`	`63`	`{`
`56`		`- var workflowId = StartWorkflow(new MyDataClass() { Value1 = 2, Value2 = 3 });`
	`64`	`+ decimal v4 = 1.235465673450897890m;`
	`65`	`+ var workflowId = StartWorkflow(new MyDataClass() {Value1 = 2, Value2 = 3, Value4 = v4, SubValue = new DataSubclass() {Value5 = v4}});`
`57`	`66`	`WaitForWorkflowToComplete(workflowId, TimeSpan.FromSeconds(30));`
`58`	`67`
`59`	`68`	`GetStatus(workflowId).Should().Be(WorkflowStatus.Complete);`
`60`	`69`	`UnhandledStepErrors.Count.Should().Be(0);`
`61`	`70`	`GetData(workflowId).Value3.Should().Be(5);`
	`71`	`+ GetData(workflowId).Value4.Should().Be(v4);`
`62`	`72`	`}`
`63`	`73`	`}`
`64`	`74`	`}`