Migrations - Added migration to segments

Layout - Fixed rotation not always applying (workaround)
Conditions - Added string operators

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

@@ -34,6 +34,36 @@ namespace Artemis.Core.Models.Profile.Conditions
         /// </summary>
         public abstract string Icon { get; }
 
+        /// <summary>
+        ///     Gets or sets whether this condition operator supports a right side, defaults to true
+        /// </summary>
+        public bool SupportsRightSide { get; protected set; } = true;
+
+        public bool SupportsType(Type type)
+        {
+            if (type == null)
+                return true;
+            return CompatibleTypes.Any(t => t.IsCastableFrom(type));
+        }
+
+        /// <summary>
+        ///     Creates a binary expression comparing two types
+        /// </summary>
+        /// <param name="leftSide">The parameter on the left side of the expression</param>
+        /// <param name="rightSide">The parameter on the right side of the expression</param>
+        /// <returns></returns>
+        public abstract BinaryExpression CreateExpression(Expression leftSide, Expression rightSide);
+
+        /// <summary>
+        ///     Returns an expression that checks the given expression for null
+        /// </summary>
+        /// <param name="expression"></param>
+        /// <returns></returns>
+        protected Expression CreateNullCheckExpression(Expression expression)
+        {
+            return Expression.NotEqual(expression, Expression.Constant(null));
+        }
+
         internal void Register(PluginInfo pluginInfo, IDataModelService dataModelService)
         {
             if (_registered)
@@ -63,20 +93,5 @@ namespace Artemis.Core.Models.Profile.Conditions
             // Profile editor service will call Unsubscribe
             _dataModelService.RemoveConditionOperator(this);
         }
-
-        public bool SupportsType(Type type)
-        {
-            if (type == null)
-                return true;
-            return CompatibleTypes.Any(t => t.IsCastableFrom(type));
-        }
-
-        /// <summary>
-        ///     Creates a binary expression comparing two types
-        /// </summary>
-        /// <param name="leftSide">The parameter on the left side of the expression</param>
-        /// <param name="rightSide">The parameter on the right side of the expression</param>
-        /// <returns></returns>
-        public abstract BinaryExpression CreateExpression(Expression leftSide, Expression rightSide);
     }
 }

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

@@ -304,7 +304,11 @@ namespace Artemis.Core.Models.Profile.Conditions
             if (leftSideAccessor.Type.IsValueType && RightStaticValue == null)
                 return;
 
-            var rightSideConstant = Expression.Constant(RightStaticValue);
+            // If the right side value is null, the constant type cannot be inferred and must be provided manually
+            var rightSideConstant = RightStaticValue != null 
+                ? Expression.Constant(RightStaticValue) 
+                : Expression.Constant(null, leftSideAccessor.Type);
+
             var conditionExpression = Operator.CreateExpression(leftSideAccessor, rightSideConstant);
 
             StaticConditionLambda = Expression.Lambda<Func<DataModel, bool>>(conditionExpression, leftSideParameter);

src/Artemis.Core/Models/Profile/Conditions/Operators/StringContainsConditionOperator.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Artemis.Core.Models.Profile.Conditions.Operators
+{
+    public class StringContainsConditionOperator : DisplayConditionOperator
+    {
+        private readonly MethodInfo _toLower;
+        private readonly MethodInfo _contains;
+
+        public StringContainsConditionOperator()
+        {
+            _toLower = typeof(string).GetMethod("ToLower", new Type[] { });
+            _contains = typeof(string).GetMethod("Contains", new[] {typeof(string) });
+        }
+
+        public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(string)};
+
+        public override string Description => "Contains";
+        public override string Icon => "Contain";
+
+        public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
+        {
+            return Expression.Equal(Expression.Call(Expression.Call(leftSide, _toLower), _contains, Expression.Call(rightSide, _toLower)), Expression.Constant(true));
+        }
+    }
+}

src/Artemis.Core/Models/Profile/Conditions/Operators/StringEndsWithConditionOperator.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Artemis.Core.Models.Profile.Conditions.Operators
+{
+    public class StringEndsWithConditionOperator : DisplayConditionOperator
+    {
+        private readonly MethodInfo _toLower;
+        private readonly MethodInfo _endsWith;
+
+        public StringEndsWithConditionOperator()
+        {
+            _toLower = typeof(string).GetMethod("ToLower", new Type[] { });
+            _endsWith = typeof(string).GetMethod("EndsWith", new[] { typeof(string) });
+        }
+
+        public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> { typeof(string) };
+
+        public override string Description => "Ends with";
+        public override string Icon => "ContainEnd";
+
+        public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
+        {
+            return Expression.Equal(Expression.Call(Expression.Call(leftSide, _toLower), _endsWith, Expression.Call(rightSide, _toLower)), Expression.Constant(true));
+        }
+    }
+}

src/Artemis.Core/Models/Profile/Conditions/Operators/StringEqualsConditionOperator.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Artemis.Core.Models.Profile.Conditions.Operators
+{
+    public class StringEqualsConditionOperator : DisplayConditionOperator
+    {
+        private readonly MethodInfo _toLower;
+
+        public StringEqualsConditionOperator()
+        {
+            _toLower = typeof(string).GetMethod("ToLower", new Type[] { });
+        }
+
+        public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(string)};
+
+        public override string Description => "Equals";
+        public override string Icon => "Equal";
+
+        public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
+        {
+            return Expression.Equal(Expression.Call(leftSide, _toLower), Expression.Call(rightSide, _toLower));
+        }
+    }
+}

src/Artemis.Core/Models/Profile/Conditions/Operators/StringNotContainsConditionOperator.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Artemis.Core.Models.Profile.Conditions.Operators
+{
+    public class StringNotContainsConditionOperator : DisplayConditionOperator
+    {
+        private readonly MethodInfo _toLower;
+        private readonly MethodInfo _contains;
+
+        public StringNotContainsConditionOperator()
+        {
+            _toLower = typeof(string).GetMethod("ToLower", new Type[] { });
+            _contains = typeof(string).GetMethod("Contains", new[] { typeof(string) });
+        }
+
+        public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> { typeof(string) };
+
+        public override string Description => "Does not contain";
+        public override string Icon => "FormatStrikethrough";
+
+        public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
+        {
+            return Expression.Equal(Expression.Call(Expression.Call(leftSide, _toLower), _contains, Expression.Call(rightSide, _toLower)), Expression.Constant(false));
+        }
+    }
+}

src/Artemis.Core/Models/Profile/Conditions/Operators/StringNotEqualConditionOperator.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Artemis.Core.Models.Profile.Conditions.Operators
+{
+    public class StringNotEqualConditionOperator : DisplayConditionOperator
+    {
+        private readonly MethodInfo _toLower;
+
+        public StringNotEqualConditionOperator()
+        {
+            _toLower = typeof(string).GetMethod("ToLower", new Type[] { });
+        }
+
+        public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(string)};
+
+        public override string Description => "Does not equal";
+        public override string Icon => "NotEqualVariant";
+
+        public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
+        {
+            return Expression.NotEqual(Expression.Call(leftSide, _toLower), Expression.Call(rightSide, _toLower));
+        }
+    }
+}

src/Artemis.Core/Models/Profile/Conditions/Operators/StringNullConditionOperator.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+
+namespace Artemis.Core.Models.Profile.Conditions.Operators
+{
+    public class StringNullConditionOperator : DisplayConditionOperator
+    {
+        public StringNullConditionOperator()
+        {
+            SupportsRightSide = false;
+        }
+
+        public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> {typeof(string)};
+
+        public override string Description => "Is null";
+        public override string Icon => "Null";
+
+        public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
+        {
+            return Expression.Equal(leftSide, Expression.Constant(null, leftSide.Type));
+        }
+    }
+}

src/Artemis.Core/Models/Profile/Conditions/Operators/StringStartsWithConditionOperator.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Artemis.Core.Models.Profile.Conditions.Operators
+{
+    public class StringStartsWithConditionOperator : DisplayConditionOperator
+    {
+        private readonly MethodInfo _toLower;
+        private readonly MethodInfo _startsWith;
+
+        public StringStartsWithConditionOperator()
+        {
+            _toLower = typeof(string).GetMethod("ToLower", new Type[] { });
+            _startsWith = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
+        }
+
+        public override IReadOnlyCollection<Type> CompatibleTypes => new List<Type> { typeof(string) };
+
+        public override string Description => "Starts with";
+        public override string Icon => "ContainStart";
+
+        public override BinaryExpression CreateExpression(Expression leftSide, Expression rightSide)
+        {
+            return Expression.Equal(Expression.Call(Expression.Call(leftSide, _toLower), _startsWith, Expression.Call(rightSide, _toLower)), Expression.Constant(true));
+        }
+    }
+}

src/Artemis.Core/Models/Surface/ArtemisDevice.cs

@@ -134,10 +134,14 @@ namespace Artemis.Core.Models.Surface
 
         internal void ApplyToRgbDevice()
         {
-            RgbDevice.Location = new Point(DeviceEntity.X, DeviceEntity.Y);
             RgbDevice.Rotation = DeviceEntity.Rotation;
             RgbDevice.Scale = DeviceEntity.Scale;
 
+            // Workaround for device rotation not applying
+            if (DeviceEntity.X == 0 && DeviceEntity.Y == 0)
+                RgbDevice.Location = new Point(1, 1);
+            RgbDevice.Location = new Point(DeviceEntity.X, DeviceEntity.Y);
+
             CalculateRenderProperties();
             OnDeviceUpdated();
         }

src/Artemis.Core/Services/DataModelService.cs

@@ -151,7 +151,21 @@ namespace Artemis.Core.Services
             {
                 if (type == null)
                     return new List<DisplayConditionOperator>(_registeredConditionOperators);
-                return _registeredConditionOperators.Where(c => c.CompatibleTypes.Any(t => t.IsCastableFrom(type))).ToList();
+
+                var candidates = _registeredConditionOperators.Where(c => c.CompatibleTypes.Any(t => t.IsCastableFrom(type))).ToList();
+
+                // If there are multiple operators with the same description, use the closest match
+                foreach (var displayConditionOperators in candidates.GroupBy(c => c.Description).Where(g => g.Count() > 1).ToList())
+                {
+                    var bestCandidate = displayConditionOperators.OrderByDescending(c => c.CompatibleTypes.Contains(type)).FirstOrDefault();
+                    foreach (var displayConditionOperator in displayConditionOperators)
+                    {
+                        if (displayConditionOperator != bestCandidate)
+                            candidates.Remove(displayConditionOperator);
+                    }
+                }
+
+                return candidates;
             }
         }
 
@@ -162,12 +176,24 @@ namespace Artemis.Core.Services
 
         private void RegisterBuiltInConditionOperators()
         {
+            // General usage for any type
             RegisterConditionOperator(Constants.CorePluginInfo, new EqualsConditionOperator());
             RegisterConditionOperator(Constants.CorePluginInfo, new NotEqualConditionOperator());
+
+            // Numeric operators
             RegisterConditionOperator(Constants.CorePluginInfo, new LessThanConditionOperator());
             RegisterConditionOperator(Constants.CorePluginInfo, new GreaterThanConditionOperator());
             RegisterConditionOperator(Constants.CorePluginInfo, new LessThanOrEqualConditionOperator());
             RegisterConditionOperator(Constants.CorePluginInfo, new GreaterThanOrEqualConditionOperator());
+
+            // String operators
+            RegisterConditionOperator(Constants.CorePluginInfo, new StringEqualsConditionOperator());
+            RegisterConditionOperator(Constants.CorePluginInfo, new StringNotEqualConditionOperator());
+            RegisterConditionOperator(Constants.CorePluginInfo, new StringContainsConditionOperator());
+            RegisterConditionOperator(Constants.CorePluginInfo, new StringNotContainsConditionOperator());
+            RegisterConditionOperator(Constants.CorePluginInfo, new StringStartsWithConditionOperator());
+            RegisterConditionOperator(Constants.CorePluginInfo, new StringEndsWithConditionOperator());
+            RegisterConditionOperator(Constants.CorePluginInfo, new StringNullConditionOperator());
         }
 
         private void PluginServiceOnPluginEnabled(object sender, PluginEventArgs e)