Data bindings - Added binding apply logic to the layer properties

Data bindings - Expanded to support inner layer properties

src/Artemis.Core/Models/Profile/DataBindings/DataBinding.cs

@@ -1,4 +1,8 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
 using Artemis.Core.DataModelExpansions;
 
 namespace Artemis.Core
@@ -11,9 +15,14 @@ namespace Artemis.Core
         private readonly List<DataBindingModifier> _modifiers = new List<DataBindingModifier>();
 
         /// <summary>
-        ///     The <see cref="BaseLayerProperty" /> that the data binding targets
+        ///     Gets the layer property this data binding targets
         /// </summary>
-        public BaseLayerProperty Target { get; set; } // BIG FAT TODO: Take into account X and Y of SkPosition etc., forgot about it again :>
+        public BaseLayerProperty LayerProperty { get; private set; }
+
+        /// <summary>
+        ///     Gets the inner property this data binding targets
+        /// </summary>
+        public PropertyInfo TargetProperty { get; private set; }
 
         /// <summary>
         ///     Gets the currently used instance of the data model that contains the source of the data binding
@@ -30,6 +39,8 @@ namespace Artemis.Core
         /// </summary>
         public IReadOnlyList<DataBindingModifier> Modifiers => _modifiers.AsReadOnly();
 
+        public Func<DataModel, object> CompiledTargetAccessor { get; private set; }
+
         /// <summary>
         ///     Adds a modifier to the data binding's <see cref="Modifiers" /> collection
         /// </summary>
@@ -55,5 +66,44 @@ namespace Artemis.Core
                 _modifiers.Remove(modifier);
             }
         }
+
+        /// <summary>
+        ///     Gets the current value of the data binding
+        /// </summary>
+        /// <param name="baseValue">The base value of the property the data binding is applied to</param>
+        /// <returns></returns>
+        public object GetValue(object baseValue)
+        {
+            if (baseValue.GetType() != TargetProperty.PropertyType)
+            {
+                throw new ArtemisCoreException($"The provided current value type ({baseValue.GetType().Name}) not match the " +
+                                               $"target property type ({TargetProperty.PropertyType.Name})");
+            }
+
+            if (CompiledTargetAccessor == null)
+                return baseValue;
+
+            var dataBindingValue = CompiledTargetAccessor(SourceDataModel);
+            foreach (var dataBindingModifier in Modifiers)
+                dataBindingValue = dataBindingModifier.Apply(dataBindingValue);
+
+            return dataBindingValue;
+        }
+
+        public void Update()
+        {
+            var listType = SourceDataModel.GetListTypeInPath(SourcePropertyPath);
+            if (listType != null)
+                throw new ArtemisCoreException($"Cannot create a regular accessor at path {SourcePropertyPath} because the path contains a list");
+
+            var parameter = Expression.Parameter(typeof(object), "targetDataModel");
+            var accessor = SourcePropertyPath.Split('.').Aggregate<string, Expression>(
+                Expression.Convert(parameter, SourceDataModel.GetType()), // Cast to the appropriate type
+                Expression.Property
+            );
+
+            var lambda = Expression.Lambda<Func<DataModel, object>>(accessor);
+            CompiledTargetAccessor = lambda.Compile();
+        }
     }
 }

src/Artemis.Core/Models/Profile/DataBindings/DataBindingModifier.cs

@@ -89,7 +89,7 @@ namespace Artemis.Core
         /// <returns>The modified value</returns>
         public object Apply(object currentValue)
         {
-            var targetType = DataBinding.Target.GetPropertyType();
+            var targetType = DataBinding.LayerProperty.GetPropertyType();
             if (currentValue.GetType() != targetType)
             {
                 throw new ArtemisCoreException("The current value of the data binding does not match the type of the target property." +
@@ -118,7 +118,7 @@ namespace Artemis.Core
                 return;
             }
 
-            var targetType = DataBinding.Target.GetPropertyType();
+            var targetType = DataBinding.LayerProperty.GetPropertyType();
             if (!modifierType.SupportsType(targetType))
             {
                 throw new ArtemisCoreException($"Cannot apply modifier type {modifierType.GetType().Name} to this modifier because " +
@@ -164,7 +164,7 @@ namespace Artemis.Core
             ParameterDataModel = null;
             ParameterPropertyPath = null;
 
-            var targetType = DataBinding.Target.GetPropertyType();
+            var targetType = DataBinding.LayerProperty.GetPropertyType();
 
             // If not null ensure the types match and if not, convert it
             if (staticValue != null && staticValue.GetType() == targetType)
@@ -200,7 +200,7 @@ namespace Artemis.Core
             else if (ParameterType == ProfileRightSideType.Static && Entity.ParameterStaticValue != null)
             {
                 // Use the target type so JSON.NET has a better idea what to do
-                var targetType = DataBinding.Target.GetPropertyType();
+                var targetType = DataBinding.LayerProperty.GetPropertyType();
                 object staticValue;
 
                 try
@@ -240,15 +240,15 @@ namespace Artemis.Core
             if (ParameterDataModel == null)
                 return;
 
-            var currentValueParameter = Expression.Parameter(DataBinding.Target.GetPropertyType());
+            var currentValueParameter = Expression.Parameter(DataBinding.LayerProperty.GetPropertyType());
 
             // If the right side value is null, the constant type cannot be inferred and must be provided based on the data binding target
             var rightSideAccessor = CreateAccessor(ParameterDataModel, ParameterPropertyPath, "right", out var rightSideParameter);
 
             // A conversion may be required if the types differ
             // This can cause issues if the DisplayConditionOperator wasn't accurate in it's supported types but that is not a concern here
-            if (rightSideAccessor.Type != DataBinding.Target.GetPropertyType())
-                rightSideAccessor = Expression.Convert(rightSideAccessor, DataBinding.Target.GetPropertyType());
+            if (rightSideAccessor.Type != DataBinding.LayerProperty.GetPropertyType())
+                rightSideAccessor = Expression.Convert(rightSideAccessor, DataBinding.LayerProperty.GetPropertyType());
 
             var modifierExpression = ModifierType.CreateExpression(currentValueParameter, rightSideAccessor);
             var lambda = Expression.Lambda<Func<object, DataModel, object>>(modifierExpression, currentValueParameter, rightSideParameter);
@@ -257,12 +257,12 @@ namespace Artemis.Core
 
         private void CreateStaticExpression()
         {
-            var currentValueParameter = Expression.Parameter(DataBinding.Target.GetPropertyType());
+            var currentValueParameter = Expression.Parameter(DataBinding.LayerProperty.GetPropertyType());
 
             // If the right side value is null, the constant type cannot be inferred and must be provided based on the data binding target
             var rightSideConstant = ParameterStaticValue != null
                 ? Expression.Constant(ParameterStaticValue)
-                : Expression.Constant(null, DataBinding.Target.GetPropertyType());
+                : Expression.Constant(null, DataBinding.LayerProperty.GetPropertyType());
 
             var modifierExpression = ModifierType.CreateExpression(currentValueParameter, rightSideConstant);
             var lambda = Expression.Lambda<Func<object, object>>(modifierExpression, currentValueParameter);