private static void ProcessChildrenConstraints(object item, IList<ValidationConstraint> constraints, ValidationConstraint parentConstraint, out string message)
 {
     StringBuilder sb = new StringBuilder();
     message = null;
     var parentConstraintIsRespected = ProcessConstraint(item, parentConstraint);
     if (!parentConstraintIsRespected) return;
     foreach (var source in constraints)
     {
         var constraintIsRespected = ProcessConstraint(item, source);
         var childConstraints = SessionManagement.Db.GetAllValidationConstraints().Where(c => c.ParentConstraint == source).ToList();
         if (constraintIsRespected && childConstraints.Any())
         {
             //Go down the tree
             string subMessage;
             ProcessChildrenConstraints(item, childConstraints, source, out subMessage);
             if (!string.IsNullOrEmpty(subMessage)) sb.AppendLine(subMessage);
         }
         else if (!constraintIsRespected && !childConstraints.Any())
         {
             //if all parents are true and the final child is false, the constraint is not respected.
             sb.AppendLine(string.Format("{0} is not respected", source));
         }
     }
     message = sb.ToString();
 }
 public ValidationConstraint SaveOrUpdateInstance(ValidationConstraint validationConstraint)
 {
     var oldItem = _cachedValidationConstraints.FirstOrDefault(vc => vc.Equals(validationConstraint));
     if (oldItem == null)
         _cachedValidationConstraints.Add(validationConstraint);
     else
     {
         _cachedValidationConstraints.Remove(oldItem);
         _cachedValidationConstraints.Add(validationConstraint);
     }
     return validationConstraint;
 }
        public void ValidationConstraints_CheckThatArgumentsProperlyParsed()
        {
            var newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Equal,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                MainArgument = "1"
            };
            TrySaveAndSucceed(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Equal,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                MainArgument = "NotAnInt"
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Between,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                MainArgument = "1",
                SecondaryArgument = "2"
            };
            TrySaveAndSucceed(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Between,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                MainArgument = "1",
                SecondaryArgument = "NotAnInt"
            };
            TrySaveAndFail(newConstraint);
        }
        public void ValidationConstraints_Validate()
        {
            const string errorMessage = "The object should not have been saved given its constraints";
            //var transac = SessionManagement.Db.StartTransaction();
            IList<ValidationConstraint> testConstraints = new List<ValidationConstraint>();
            try
            {
                var accor = SessionManagement.Db.GetAllAssets().SingleOrDefault(a => a.Name == "ACCOR");
                var total = SessionManagement.Db.GetAllAssets().SingleOrDefault(a => a.Name == "TOTAL");
                Assert.IsNotNull(total);
                var nameConstraint = new ValidationConstraint
                {
                    ConstraintType = trkValidationConstraintType.Equal,
                    ObjectType = _typeOfAssetEditable,
                    Property = "Name",
                    PropertyType = _typeOfString,
                    MainArgument = "ACCOR"
                };
                testConstraints.Add(nameConstraint);
                var savedNameConstraint = ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints).SingleOrDefault();
                //Should succeed
                ValidationConstraintService.Instance.ValidateObject(accor);
                //Should fail
                try
                {
                    ValidationConstraintService.Instance.ValidateObject(total);
                    Assert.Fail(errorMessage);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }

                //Second Level
                var idConstraint1 = new ValidationConstraint
                {
                    ConstraintType = trkValidationConstraintType.Greater,
                    ObjectType = _typeOfAssetEditable,
                    Property = "Id",
                    PropertyType = _typeOfString,
                    MainArgument = "0",
                    ParentConstraint = savedNameConstraint
                };
                testConstraints.Add(idConstraint1);
                ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints);
                //Should succeed
                ValidationConstraintService.Instance.ValidateObject(accor);

                //Should Fail (Id = 122)
                var idConstraint2 = new ValidationConstraint
                {
                    ConstraintType = trkValidationConstraintType.Lower,
                    ObjectType = _typeOfAssetEditable,
                    Property = "Id",
                    PropertyType = _typeOfString,
                    MainArgument = "30",
                    ParentConstraint = savedNameConstraint
                };
                testConstraints.Add(idConstraint2);
                testConstraints = ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints);
                try
                {
                    ValidationConstraintService.Instance.ValidateObject(accor);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
                //Remove it now that it has been tested
                testConstraints.ToList().ForEach(c =>
                {
                    if (c == idConstraint2)
                        c.RequiresDeletion = true;
                });

                var handlingQuotesConstraint = new ValidationConstraint
                {
                    ConstraintType = trkValidationConstraintType.True,
                    ObjectType = _typeOfAssetEditable,
                    Property = "HandlingQuotes",
                    PropertyType = _typeOfBool,
                    ParentConstraint = savedNameConstraint
                };
                testConstraints.Add(handlingQuotesConstraint);
                var thirdLevel = ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints).SingleOrDefault(c => c.ToString() == handlingQuotesConstraint.ToString());
                //Should succeed
                ValidationConstraintService.Instance.ValidateObject(accor);

                var betweenConstraint = new ValidationConstraint
                {
                    ConstraintType = trkValidationConstraintType.Between,
                    ObjectType = _typeOfAssetEditable,
                    Property = "Id",
                    PropertyType = _typeOfInt,
                    MainArgument = "0",
                    SecondaryArgument = "100000000",
                    ParentConstraint = thirdLevel
                };
                testConstraints.Add(betweenConstraint);
                ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints);
                //Should succeed
                ValidationConstraintService.Instance.ValidateObject(accor);

                var notNullConstraint = new ValidationConstraint
                {
                    ConstraintType = trkValidationConstraintType.NotNull,
                    ObjectType = _typeOfAssetEditable,
                    Property = "Status",
                    PropertyType = _typeOfAssetStatus,
                    ParentConstraint = thirdLevel
                };
                testConstraints.Add(notNullConstraint);
                ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints);

                //Should succeed
                ValidationConstraintService.Instance.ValidateObject(accor);

                var differentConstraint = new ValidationConstraint
                {
                    ConstraintType = trkValidationConstraintType.Different,
                    ObjectType = _typeOfAssetEditable,
                    Property = "Id",
                    PropertyType = _typeOfInt,
                    MainArgument = "1",
                    ParentConstraint = thirdLevel
                };

                testConstraints.Add(differentConstraint);
                ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints);
                //Should succeed
                ValidationConstraintService.Instance.ValidateObject(accor);

                var nullConstraint = new ValidationConstraint
                {
                    ConstraintType = trkValidationConstraintType.Null,
                    ObjectType = _typeOfAssetEditable,
                    Property = "AssetType",
                    PropertyType = _typeOfAssetType,
                    ParentConstraint = thirdLevel
                };
                testConstraints.Add(nullConstraint);
                ValidationConstraintService.Instance.SaveOrUpdateList(testConstraints);
                try
                {
                    //Should fail.
                    ValidationConstraintService.Instance.ValidateObject(accor);
                    Assert.Fail(errorMessage);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }
                //If you want to add constraint remove the top one from the list.
            }
            finally
            {
                //SessionManagement.Db.RollbackTrans(transac);
            }
        }
 public void ValidationConstraints_Update()
 {
     var constraintsToSave = new List<ValidationConstraint>();
     var newConstraint = new ValidationConstraint
     {
         ConstraintType = trkValidationConstraintType.False,
         ObjectType = _typeOfAssetEditable,
         Property = "HandlingQuotes",
         PropertyType = _typeOfBool,
     };
     constraintsToSave.Add(newConstraint);
     var savedItem = ValidationConstraintService.Instance.SaveOrUpdateList(constraintsToSave).Single();
     constraintsToSave.Clear();
     savedItem.ConstraintType = trkValidationConstraintType.True;
     constraintsToSave.Add(savedItem);
     savedItem = ValidationConstraintService.Instance.SaveOrUpdateList(constraintsToSave).Single();
     constraintsToSave.Clear();
     Assert.AreEqual(savedItem.ConstraintType, trkValidationConstraintType.True);
     savedItem.RequiresDeletion = true;
     constraintsToSave.Add(newConstraint);
     ValidationConstraintService.Instance.SaveOrUpdateList(constraintsToSave);
     var supposedToHaveBeenErased = ValidationConstraintService.Instance.GetValidationConstraintById(savedItem.ToString());
     if (supposedToHaveBeenErased != null)
     {
         Assert.Fail(supposedToHaveBeenErased.ToString());
     }
 }
        public void ValidationConstraints_SecondGreaterThanMainArgument()
        {
            var newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Between,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                MainArgument = "1",
                SecondaryArgument = "2"
            };
            TrySaveAndSucceed(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Between,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                MainArgument = "1",
                SecondaryArgument = "0"
            };
            TrySaveAndFail(newConstraint);
        }
        public void ValidationConstraints_SaveSomeConstraints()
        {
            var portfolioType = new PortfolioEditable().GetType().AssemblyQualifiedName;
            var userInfoType = new UserInfo().GetType().AssemblyQualifiedName;

            var newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.NotNull,
                ObjectType = portfolioType,
                Property = "Comment",
                PropertyType = portfolioType
            };
            var newConstraint2 = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.NotNull,
                ObjectType = portfolioType,
                Property = "Manager",
                PropertyType = userInfoType
            };

            var constraintsToSave = new List<ValidationConstraint> { newConstraint, newConstraint2 };
            ValidationConstraintService.Instance.SaveOrUpdateList(constraintsToSave);
        }
        public void ValidationConstraints_Save()
        {
            var newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.NotNull,
                ObjectType = _typeOfAssetEditable,
                Property = "Code",
                PropertyType = _typeOfString
            };
            TrySaveAndSucceed(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Null,
                ObjectType = _typeOfAssetEditable,
                Property = "Code",
                PropertyType = _typeOfString
            };
            TrySaveAndSucceed(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.NotNull,
                ObjectType = _typeOfAssetEditable,
                Property = "Status",
                PropertyType = _typeOfAssetStatus
            };
            TrySaveAndSucceed(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Null,
                ObjectType = _typeOfAssetEditable,
                Property = "Status",
                PropertyType = _typeOfAssetStatus
            };
            TrySaveAndSucceed(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Equal,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                MainArgument = "1"
            };
            TrySaveAndSucceed(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Different,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                MainArgument = "1"
            };
            TrySaveAndSucceed(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Greater,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                MainArgument = "1"
            };
            TrySaveAndSucceed(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Lower,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                MainArgument = "1"
            };
            TrySaveAndSucceed(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.True,
                ObjectType = _typeOfAssetEditable,
                Property = "HandlingQuotes",
                PropertyType = _typeOfBool,
            };
            TrySaveAndSucceed(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.False,
                ObjectType = _typeOfAssetEditable,
                Property = "HandlingQuotes",
                PropertyType = _typeOfBool,
            };
            TrySaveAndSucceed(newConstraint);
        }
 /*override*/
 protected ValidationConstraint SaveOrUpdateObject(ValidationConstraint validationConstraint)
 {
     //return validationConstraint.IsNew ? SessionManagement.Db.SaveNew(validationConstraint) : SessionManagement.Db.Update(validationConstraint);
     return SessionManagement.Db.SaveOrUpdateInstance(validationConstraint);
 }
        public void ValidationConstraints_DeleteParentFails()
        {
            //var transaction = SessionManagement.Db.StartTransaction();
            try
            {
                //Check that a validation constraint cannot reference itself
                var parentConstraint = new ValidationConstraint
                {
                    ConstraintType = trkValidationConstraintType.NotNull,
                    ObjectType = _typeOfAssetEditable,
                    Property = "Id",
                    PropertyType = _typeOfInt,
                };

                var childConstraint = new ValidationConstraint
                {
                    ConstraintType = trkValidationConstraintType.NotNull,
                    ObjectType = _typeOfAssetEditable,
                    Property = "Code",
                    PropertyType = _typeOfString,
                };

                var constraintsToSave = new List<ValidationConstraint> { parentConstraint, childConstraint };
                var savedConstraints = ValidationConstraintService.Instance.SaveOrUpdateList(constraintsToSave);
                Assert.IsNotNull(savedConstraints);
                savedConstraints[1].ParentConstraint = savedConstraints[0];
                savedConstraints = ValidationConstraintService.Instance.SaveOrUpdateList(constraintsToSave);
                savedConstraints[0].RequiresDeletion = true;
                TrySaveAndFail(savedConstraints);
            }
            finally
            {
                //SessionManagement.Db.RollbackTrans(transaction);
            }
        }
 /*override*/
 protected void DeleteObject(ValidationConstraint obj)
 {
     string message;
     if (CanBeDeleted(obj, out message))
         SessionManagement.Db.Delete(obj);
     else
         throw new Exception(message);
 }
        /*override*/
        protected bool CanBeSaved(ValidationConstraint constraint, out string message)
        {
            StringBuilder sb = new StringBuilder();
            if (constraint.ParentConstraint != null && Equals(constraint, constraint.ParentConstraint))
                sb.AppendLine("A constraint cannot reference itself as parent");
            var test = Type.GetType(constraint.PropertyType);
            if (test == null)
                sb.AppendLine("The Object Type associated to the constraint could not be found");
            if (test != null && test.IsSubclassOf(typeof(ObjectBase)))
                switch (constraint.ConstraintType)
                {
                    case trkValidationConstraintType.False:
                    case trkValidationConstraintType.True:
                    case trkValidationConstraintType.Greater:
                    case trkValidationConstraintType.Lower:
                    case trkValidationConstraintType.Between:
                    case trkValidationConstraintType.Equal:
                        sb.AppendLine(string.Format("The constraint type specified cannot be applied to the selected parameter {0}", constraint));
                        break;
                }
            if (string.IsNullOrEmpty(sb.ToString()) && constraint.MainArgument != null || constraint.SecondaryArgument != null)
            {
                switch (constraint.ConstraintType)
                {
                    case trkValidationConstraintType.Null:
                    case trkValidationConstraintType.NotNull:
                        sb.AppendLine(string.Format(string.Format("The arguments you specified are incompatible with the constraint type {0}"),constraint));
                        break;
                    case trkValidationConstraintType.Between:
                        if (!(constraint.MainArgument != null && constraint.SecondaryArgument != null))
                            sb.AppendLine("Both arguments must be specified");
                        break;
                }
                try
                {
                    Object mainArgument = null;
                    Object secondArgument = null;
                    if (constraint.MainArgument != null)
                    {
                        MethodInfo m = test.GetMethod("Parse", new[] { typeof(string) });
                        if (m != null)
                        {
                            mainArgument = m.Invoke(null, new[] { constraint.MainArgument });
                            if (mainArgument == null) throw new Exception();
                        }
                    }
                    if (constraint.SecondaryArgument != null && constraint.ConstraintType == trkValidationConstraintType.Between)
                    {
                        MethodInfo m = test.GetMethod("Parse", new[] { typeof(string) });
                        if (m != null)
                        {
                            secondArgument = m.Invoke(null, new[] { constraint.SecondaryArgument });
                            if (secondArgument == null) throw new Exception();
                        }
                        // MainArgument < SecondArgument when it is a between constraint.
                        if (ValidationConstraintHelper.IsGreater(secondArgument, mainArgument))
                            sb.AppendLine("The second argument must be greater than the first");
                    }
                    else if (constraint.SecondaryArgument != null)
                        sb.AppendLine("The second argument is only used in the Between constraint and will therefore be ignored");
                }
                catch (Exception)
                {
                    throw new Exception();
                    //throw new FunctionalException(string.Format(ExceptionDictionary.The_value_of_the_argument_could_not_be_correctly_translated_into_the_specified_type, constraint));
                }
            }

            if ((constraint.ConstraintType == trkValidationConstraintType.True || constraint.ConstraintType == trkValidationConstraintType.False) && constraint.PropertyType != typeof(bool).AssemblyQualifiedName)
            {
                sb.AppendLine(string.Format("{0} is not a boolean and_therefore not compatible with_a {1} constraint", constraint.Property, constraint.ConstraintType));
                //sb.AppendLine(string.Format(ExceptionDictionary._0__is_not_a_boolean_and_therefore_not_compatible_with_a__1__constraint, constraint.Property, constraint.ConstraintType));
            }
            message = sb.ToString();
            return string.IsNullOrEmpty(message);
        }
 /*override*/
 protected bool CanBeDeleted(ValidationConstraint obj, out string message)
 {
     message = string.Empty;
     StringBuilder sb = new StringBuilder();
     var children = SessionManagement.Db.GetAllValidationConstraints().Where(c => Equals(c.ParentConstraint, obj)).ToList();
     if (children.Any())
         sb.AppendLine(string.Format("The constraint {0} cannot be deleted because it is linked to child constraints", obj));
     message = sb.ToString();
     return string.IsNullOrEmpty(message);
 }
        public void ValidationConstraints_ValidateDeepTree()
        {
            var asset = SessionManagement.Db.GetAllAssets().FirstOrDefault(a => a.Name == "ACCOR");
            var firstConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Equal,
                ObjectType = _typeOfAssetEditable,
                Property = "Name",
                PropertyType = _typeOfString,
                MainArgument = "ACCOR"
            };

            var secondConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Equal,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                ParentConstraint = firstConstraint,
                MainArgument = "124"
            };

            var thirdConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.NotNull,
                ObjectType = _typeOfAssetEditable,
                Property = "Code",
                ParentConstraint = secondConstraint,
                PropertyType = _typeOfString,
            };
            ValidationConstraintService.Instance.SaveOrUpdateList(new List<ValidationConstraint>{firstConstraint, secondConstraint, thirdConstraint});
            ValidationConstraintService.Instance.ValidateObject(asset);
        }
        public void ValidationConstraints_SaveFailed()
        {
            var newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.False,
                ObjectType = _typeOfAssetEditable,
                Property = "Status",
                PropertyType = _typeOfAssetStatus
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.True,
                ObjectType = _typeOfAssetEditable,
                Property = "Status",
                PropertyType = _typeOfAssetStatus
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Greater,
                ObjectType = _typeOfAssetEditable,
                Property = "Status",
                PropertyType = _typeOfAssetStatus
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Lower,
                ObjectType = _typeOfAssetEditable,
                Property = "Status",
                PropertyType = _typeOfAssetStatus
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Between,
                ObjectType = _typeOfAssetEditable,
                Property = "Status",
                PropertyType = _typeOfAssetStatus
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Equal,
                ObjectType = _typeOfAssetEditable,
                Property = "Status",
                PropertyType = _typeOfAssetStatus
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.True,
                ObjectType = _typeOfAssetEditable,
                Property = "Code",
                PropertyType = _typeOfString
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.False,
                ObjectType = _typeOfAssetEditable,
                Property = "Code",
                PropertyType = _typeOfString
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.False,
                ObjectType = _typeOfAssetEditable,
                Property = "UnknownProperty",
                PropertyType = _typeOfString
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Between,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                MainArgument = "1"
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Between,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                SecondaryArgument = "1"
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.NotNull,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                SecondaryArgument = "1"
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.Null,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
                SecondaryArgument = "1"
            };
            TrySaveAndFail(newConstraint);

            newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.NotNull,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = "RandomTypeThatDoesNotExist",
            };
            TrySaveAndFail(newConstraint);
        }
 private static void TrySaveAndSucceed(ValidationConstraint constraintsToSave)
 {
     var constraintsList = new List<ValidationConstraint> { constraintsToSave };
     TrySaveAndSucceed(constraintsList);
 }
        public void ValidationConstraints_SaveItselfAsParentFails()
        {
            //Check that a validation constraint cannot reference itself
            var newConstraint = new ValidationConstraint
            {
                ConstraintType = trkValidationConstraintType.NotNull,
                ObjectType = _typeOfAssetEditable,
                Property = "Id",
                PropertyType = _typeOfInt,
            };

            var constraintsToSave = new List<ValidationConstraint> { newConstraint };
            var savedConstraint = ValidationConstraintService.Instance.SaveOrUpdateList(constraintsToSave).SingleOrDefault();
            Assert.IsNotNull(savedConstraint);
            constraintsToSave.Clear();
            savedConstraint.ParentConstraint = savedConstraint;
            TrySaveAndFail(newConstraint);

            ////Finally delete the constraint that had to be saved.
            //savedConstraint.RequiresDeletion = true;
            //constraintsToSave.Add(newConstraint);
            //ValidationConstraintService.Instance.SaveOrUpdateList(constraintsToSave);
            //Assert.IsNull(ValidationConstraintService.Instance.GetValidationConstraintById(savedConstraint.ToString()));
            //constraintsToSave.Clear();
        }
 private static bool ProcessConstraint(object item, ValidationConstraint constraint)
 {
     var argumentType = item.GetType();
     object mainArgument = null;
     object secondArgument = null;
     if (constraint.ObjectType == argumentType.AssemblyQualifiedName)
     {
         var evaluator = new ExpressionEvaluator();
         var propertyValue = evaluator.GetValue(item, constraint.Property);
         if (constraint.MainArgument != null) mainArgument = GetValue(constraint.MainArgument, propertyValue.GetType());
         if (constraint.SecondaryArgument != null) secondArgument = GetValue(constraint.SecondaryArgument, propertyValue.GetType());
         switch (constraint.ConstraintType)
         {
             case trkValidationConstraintType.Null:
                 if (propertyValue is string)
                     return string.IsNullOrEmpty(propertyValue.ToString());
                 return (propertyValue == null);
             case trkValidationConstraintType.NotNull:
                 if (propertyValue is string)
                     return !string.IsNullOrEmpty((string)propertyValue.ToString());
                 return (propertyValue != null);
             case trkValidationConstraintType.Greater:
                 if (mainArgument == null) return false;
                 return IsGreater(mainArgument, propertyValue);
             case trkValidationConstraintType.Lower:
                 if (mainArgument == null) return false;
                 return IsGreater(propertyValue, mainArgument);
             case trkValidationConstraintType.Equal:
                 if (mainArgument == null) return false;
                 return AreEqual(propertyValue, mainArgument);
             case trkValidationConstraintType.Between:
                 if (mainArgument == null) return false;
                 if (secondArgument == null) return false;
                 return (IsGreater(mainArgument, propertyValue) && IsGreater(propertyValue, secondArgument));
             case trkValidationConstraintType.Different:
                 return !AreEqual(propertyValue, mainArgument);
             case trkValidationConstraintType.False:
                 return !((bool)propertyValue);
             case trkValidationConstraintType.True:
                 return ((bool)propertyValue);
             default:
                 throw new ArgumentOutOfRangeException();
         }
     }
     return false;
 }
 public void Delete(ValidationConstraint validationConstraint)
 {
     if (_cachedValidationConstraints.FirstOrDefault(vc => vc.Equals(validationConstraint)) != null)
         _cachedValidationConstraints.Remove(validationConstraint);
 }