Data model conditions - Added event predicates (WIP commit)

src/Artemis.Core/Models/Profile/Conditions/DataModelConditionEvent.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using Artemis.Storage.Entities.Profile.Abstract;
 using Artemis.Storage.Entities.Profile.Conditions;
 
@@ -39,6 +40,7 @@ namespace Artemis.Core
         /// </summary>
         public DataModelPath? EventPath { get; private set; }
 
+        public Type? EventArgumentType { get; set; }
 
         internal DataModelConditionEventEntity Entity { get; set; }
 
@@ -57,6 +59,11 @@ namespace Artemis.Core
                 return false;
 
             _eventTriggered = false;
+
+            // If there is a child (root group), it must evaluate to true whenever the event triggered
+            if (Children.Any())
+                return Children[0].Evaluate();
+            // If there are no children, we always evaluate to true whenever the event triggered
             return true;
         }
 
@@ -84,6 +91,31 @@ namespace Artemis.Core
             EventPath?.Dispose();
             EventPath = path != null ? new DataModelPath(path) : null;
             SubscribeToEventPath();
+
+            // Remove the old root group that was tied to the old data model
+            while (Children.Any())
+                RemoveChild(Children[0]);
+
+            if (EventPath != null)
+            {
+                EventArgumentType = GetEventArgumentType();
+                // Create a new root group
+                AddChild(new DataModelConditionGroup(this));
+            }
+            else
+            {
+                EventArgumentType = null;
+            }
+        }
+
+        private Type? GetEventArgumentType()
+        {
+            if (EventPath == null || !EventPath.IsValid)
+                return null;
+
+            // Cannot rely on EventPath.GetValue() because part of the path might be null
+            Type eventType = EventPath.GetPropertyType()!;
+            return eventType.IsGenericType ? eventType.GetGenericArguments()[0] : typeof(DataModelEventArgs);
         }
 
         #region IDisposable
@@ -117,6 +149,12 @@ namespace Artemis.Core
             // Target list
             EventPath?.Save();
             Entity.EventPath = EventPath?.Entity;
+
+            // Children
+            Entity.Children.Clear();
+            Entity.Children.AddRange(Children.Select(c => c.GetEntity()));
+            foreach (DataModelConditionPart child in Children)
+                child.Save();
         }
 
         internal override DataModelConditionPartEntity GetEntity()
@@ -137,6 +175,18 @@ namespace Artemis.Core
 
             EventPath = eventPath;
             SubscribeToEventPath();
+
+            EventArgumentType = GetEventArgumentType();
+            // There should only be one child and it should be a group
+            if (Entity.Children.FirstOrDefault() is DataModelConditionGroupEntity rootGroup)
+            {
+                AddChild(new DataModelConditionGroup(this, rootGroup));
+            }
+            else
+            {
+                Entity.Children.Clear();
+                AddChild(new DataModelConditionGroup(this));
+            }
         }
 
         private bool PointsToEvent(DataModelPath dataModelPath)

src/Artemis.Core/Models/Profile/Conditions/DataModelConditionEventPredicate.cs

@@ -0,0 +1,154 @@
+using System;
+using Artemis.Storage.Entities.Profile;
+using Artemis.Storage.Entities.Profile.Conditions;
+
+namespace Artemis.Core
+{
+    /// <summary>
+    ///     A predicate like evaluated inside a <see cref="DataModelConditionEvent" />
+    /// </summary>
+    public class DataModelConditionEventPredicate : DataModelConditionPredicate
+    {
+        /// <summary>
+        ///     Creates a new instance of the <see cref="DataModelConditionEventPredicate" /> class
+        /// </summary>
+        /// <param name="parent"></param>
+        /// <param name="predicateType"></param>
+        public DataModelConditionEventPredicate(DataModelConditionPart parent, ProfileRightSideType predicateType)
+            : base(parent, predicateType, new DataModelConditionEventPredicateEntity())
+        {
+            DataModelConditionEvent = null!;
+            ApplyParentEvent();
+            Initialize();
+        }
+
+        internal DataModelConditionEventPredicate(DataModelConditionPart parent, DataModelConditionEventPredicateEntity entity)
+            : base(parent, entity)
+        {
+            DataModelConditionEvent = null!;
+            ApplyParentEvent();
+            Initialize();
+        }
+
+        /// <summary>
+        ///     Gets the data model condition event this predicate belongs to
+        /// </summary>
+        public DataModelConditionEvent DataModelConditionEvent { get; private set; }
+
+        private void ApplyParentEvent()
+        {
+            DataModelConditionPart? current = Parent;
+            while (current != null)
+            {
+                if (current is DataModelConditionEvent parentEvent)
+                {
+                    DataModelConditionEvent = parentEvent;
+                    return;
+                }
+
+                current = current.Parent;
+            }
+
+            if (DataModelConditionEvent == null)
+                throw new ArtemisCoreException("This data model condition event predicate does not belong to a data model condition event");
+        }
+
+        private object? GetEventPathValue(DataModelPath path, object target)
+        {
+            if (!(path.Target is EventPredicateWrapperDataModel wrapper))
+                throw new ArtemisCoreException("Data model condition event predicate has a path with an invalid target");
+
+            wrapper.UntypedArguments = target;
+            return path.GetValue();
+        }
+
+        #region Initialization
+
+        protected override void InitializeLeftPath()
+        {
+            if (Entity.LeftPath != null)
+                LeftPath = DataModelConditionEvent.EventArgumentType != null
+                    ? new DataModelPath(EventPredicateWrapperDataModel.Create(DataModelConditionEvent.EventArgumentType), Entity.LeftPath)
+                    : null;
+        }
+
+        protected override void InitializeRightPath()
+        {
+            if (PredicateType == ProfileRightSideType.Dynamic && Entity.RightPath != null)
+            {
+                // Right side dynamic using event arguments
+                if (Entity.RightPath.WrapperType == PathWrapperType.Event)
+                {
+                    RightPath = DataModelConditionEvent.EventArgumentType != null
+                        ? new DataModelPath(EventPredicateWrapperDataModel.Create(DataModelConditionEvent.EventArgumentType), Entity.RightPath)
+                        : null;
+                }
+                // Right side dynamic
+                else
+                    RightPath = new DataModelPath(null, Entity.RightPath);
+            }
+        }
+
+        #endregion
+
+        #region Modification
+
+        /// <inheritdoc />
+        public override Type? GetPreferredRightSideType()
+        {
+            Type? preferredType = Operator?.RightSideType;
+            Type? leftSideType = LeftPath?.GetPropertyType();
+            if (preferredType == null)
+                return null;
+
+            if (leftSideType != null && preferredType.IsAssignableFrom(leftSideType))
+                preferredType = leftSideType;
+
+            return preferredType;
+        }
+
+        #endregion
+
+        #region Evaluation
+
+        /// <summary>
+        ///     Not supported for event predicates, always returns <c>false</c>
+        /// </summary>
+        public override bool Evaluate()
+        {
+            return false;
+        }
+
+        internal override bool EvaluateObject(object target)
+        {
+            if (Operator == null || LeftPath == null || !LeftPath.IsValid)
+                return false;
+
+            // Compare with a static value
+            if (PredicateType == ProfileRightSideType.Static)
+            {
+                object? leftSideValue = GetEventPathValue(LeftPath, target);
+                if (leftSideValue != null && leftSideValue.GetType().IsValueType && RightStaticValue == null)
+                    return false;
+
+                return Operator.InternalEvaluate(leftSideValue, RightStaticValue);
+            }
+
+            if (RightPath == null || !RightPath.IsValid)
+                return false;
+
+            // Compare with dynamic values
+            if (PredicateType == ProfileRightSideType.Dynamic)
+            {
+                // If the path targets a property inside the event, evaluate on the event path value instead of the right path value
+                if (RightPath.Target is EventPredicateWrapperDataModel)
+                    return Operator.InternalEvaluate(GetEventPathValue(LeftPath, target), GetEventPathValue(RightPath, target));
+                return Operator.InternalEvaluate(GetEventPathValue(LeftPath, target), RightPath.GetValue());
+            }
+
+            return false;
+        }
+
+        #endregion
+    }
+}

src/Artemis.Core/Models/Profile/Conditions/DataModelConditionListPredicate.cs

@@ -1,4 +1,5 @@
 using System;
+using Artemis.Storage.Entities.Profile;
 using Artemis.Storage.Entities.Profile.Conditions;
 
 namespace Artemis.Core
@@ -76,11 +77,12 @@ namespace Artemis.Core
             if (PredicateType == ProfileRightSideType.Dynamic && Entity.RightPath != null)
             {
                 // Right side dynamic inside the list
-                // TODO: Come up with a general wrapper solution because this will clash with events
-                if (Entity.RightPath.DataModelGuid == Constants.CorePluginInfo.Guid)
+                if (Entity.RightPath.WrapperType == PathWrapperType.List)
+                {
                     RightPath = DataModelConditionList.ListType != null
                         ? new DataModelPath(ListPredicateWrapperDataModel.Create(DataModelConditionList.ListType), Entity.RightPath)
                         : null;
+                }
                 // Right side dynamic
                 else
                     RightPath = new DataModelPath(null, Entity.RightPath);

src/Artemis.Core/Models/Profile/Conditions/Wrappers/EventPredicateWrapperDataModel.cs

@@ -0,0 +1,37 @@
+using System;
+using Artemis.Core.DataModelExpansions;
+
+namespace Artemis.Core
+{
+    internal class EventPredicateWrapperDataModel<T> : EventPredicateWrapperDataModel
+    {
+        [DataModelProperty(Name = "Event arguments", Description = "The arguments provided when the event triggers")]
+        public T Arguments => (UntypedArguments is T typedArguments ? typedArguments : default)!;
+    }
+
+    /// <summary>
+    ///     Represents a datamodel that wraps the event arguments of an event
+    /// </summary>
+    public abstract class EventPredicateWrapperDataModel : DataModel
+    {
+        internal EventPredicateWrapperDataModel()
+        {
+            PluginInfo = Constants.CorePluginInfo;
+        }
+
+        [DataModelIgnore]
+        public object? UntypedArguments { get; set; }
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="EventPredicateWrapperDataModel"/> class
+        /// </summary>
+        public static EventPredicateWrapperDataModel Create(Type type)
+        {
+            object? instance = Activator.CreateInstance(typeof(EventPredicateWrapperDataModel<>).MakeGenericType(type));
+            if (instance == null)
+                throw new ArtemisCoreException($"Failed to create an instance of EventPredicateWrapperDataModel<T> for type {type.Name}");
+
+            return (EventPredicateWrapperDataModel) instance;
+        }
+    }
+}

src/Artemis.Core/Models/Profile/Conditions/Wrappers/ListPredicateWrapperDataModel.cs

@@ -9,6 +9,9 @@ namespace Artemis.Core
         public T Value => (UntypedValue is T typedValue ? typedValue : default)!;
     }
 
+    /// <summary>
+    ///     Represents a datamodel that wraps a value in a list
+    /// </summary>
     public abstract class ListPredicateWrapperDataModel : DataModel
     {
         internal ListPredicateWrapperDataModel()
@@ -19,6 +22,9 @@ namespace Artemis.Core
         [DataModelIgnore]
         public object? UntypedValue { get; set; }
 
+        /// <summary>
+        /// Creates a new instance of the <see cref="ListPredicateWrapperDataModel"/> class
+        /// </summary>
         public static ListPredicateWrapperDataModel Create(Type type)
         {
             object? instance = Activator.CreateInstance(typeof(ListPredicateWrapperDataModel<>).MakeGenericType(type));

src/Artemis.Core/Models/Profile/DataModel/DataModelEvent.cs

@@ -58,6 +58,9 @@ namespace Artemis.Core
         /// </summary>
         public void Trigger()
         {
+            DataModelEventArgs eventArgs = new DataModelEventArgs {TriggerTime = DateTime.Now};
+
+            LastEventArguments = eventArgs;
             LastTrigger = DateTime.Now;
             TriggerCount++;
 
@@ -74,10 +77,15 @@ namespace Artemis.Core
 
         /// <inheritdoc />
         public int TriggerCount { get; private set; }
-        
+
+        /// <summary>
+        ///     Gets the event arguments of the last time the event was triggered
+        /// </summary>
+        public DataModelEventArgs? LastEventArguments { get; private set; }
+
         /// <inheritdoc />
         [DataModelIgnore]
-        public Type? ArgumentsType => null;
+        public Type ArgumentsType => typeof(DataModelEventArgs);
 
         /// <inheritdoc />
         public event EventHandler? EventTriggered;

src/Artemis.Core/Models/Profile/DataModel/IDataModelEvent.cs

@@ -17,7 +17,7 @@ namespace Artemis.Core
         /// <summary>
         ///     Gets the type of arguments this event contains
         /// </summary>
-        Type? ArgumentsType { get; }
+        Type ArgumentsType { get; }
 
         /// <summary>
         ///     Fires when the event is triggered