Example #1
0
        protected override void UpdateListViewItem(object ruleObject, ListViewItem listViewItem)
        {
            bool              flag;
            RuleSet           set             = ruleObject as RuleSet;
            ValidationManager serviceProvider = new ValidationManager(base.Activity.Site);
            ITypeProvider     service         = (ITypeProvider)serviceProvider.GetService(typeof(ITypeProvider));
            RuleValidation    validation      = new RuleValidation(base.Activity, service, false);

            using (WorkflowCompilationContext.CreateScope(serviceProvider))
            {
                flag = set.Validate(validation);
            }
            listViewItem.Tag  = set;
            listViewItem.Text = set.Name;
            string text = flag ? Messages.Yes : Messages.No;

            if (listViewItem.SubItems.Count == 1)
            {
                listViewItem.SubItems.Add(text);
            }
            else
            {
                listViewItem.SubItems[1].Text = text;
            }
        }
        protected override void UpdateListViewItem(object ruleObject, ListViewItem listViewItem)
        {
            RuleSet ruleSet = ruleObject as RuleSet;

            ValidationManager manager      = new ValidationManager(this.Activity.Site);
            ITypeProvider     typeProvider = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
            RuleValidation    validation   = new RuleValidation(this.Activity, typeProvider, false);

            bool valid;

            using (WorkflowCompilationContext.CreateScope(manager))
            {
                valid = ruleSet.Validate(validation);
            }

            listViewItem.Tag  = ruleSet;
            listViewItem.Text = ruleSet.Name;
            string validText = valid ? Messages.Yes : Messages.No;

            if (listViewItem.SubItems.Count == 1)
            {
                listViewItem.SubItems.Add(validText);
            }
            else
            {
                listViewItem.SubItems[1].Text = validText;
            }
        }
 internal void ValidateDefinition(Activity root, bool isNewType, ITypeProvider typeProvider)
 {
     if (this.validateOnCreate)
     {
         ValidationErrorCollection errors = new ValidationErrorCollection();
         if (typeProvider == null)
         {
             typeProvider = WorkflowRuntime.CreateTypeProvider(root);
         }
         if (!isNewType)
         {
             if (!string.IsNullOrEmpty(root.GetValue(WorkflowMarkupSerializer.XClassProperty) as string))
             {
                 errors.Add(new ValidationError(ExecutionStringManager.XomlWorkflowHasClassName, 0x61c));
             }
             Queue queue = new Queue();
             queue.Enqueue(root);
             while (queue.Count > 0)
             {
                 Activity activity = queue.Dequeue() as Activity;
                 if (activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) != null)
                 {
                     errors.Add(new ValidationError(ExecutionStringManager.XomlWorkflowHasCode, 0x61d));
                 }
                 CompositeActivity activity2 = activity as CompositeActivity;
                 if (activity2 != null)
                 {
                     foreach (Activity activity3 in activity2.EnabledActivities)
                     {
                         queue.Enqueue(activity3);
                     }
                 }
             }
         }
         ServiceContainer serviceProvider = new ServiceContainer();
         serviceProvider.AddService(typeof(ITypeProvider), typeProvider);
         ValidationManager manager = new ValidationManager(serviceProvider);
         using (WorkflowCompilationContext.CreateScope(manager))
         {
             foreach (Validator validator in manager.GetValidators(root.GetType()))
             {
                 foreach (ValidationError error in validator.Validate(manager, root))
                 {
                     if (!error.UserData.Contains(typeof(Activity)))
                     {
                         error.UserData[typeof(Activity)] = root;
                     }
                     errors.Add(error);
                 }
             }
         }
         if (errors.HasErrors)
         {
             throw new WorkflowValidationFailedException(ExecutionStringManager.WorkflowValidationFailure, errors);
         }
     }
 }
Example #4
0
        public ValidationErrorCollection Validate()
        {
            ValidationErrorCollection errors;
            TypeProvider     serviceInstance = CreateTypeProvider(this.originalRootActivity);
            ServiceContainer serviceProvider = new ServiceContainer();

            serviceProvider.AddService(typeof(ITypeProvider), serviceInstance);
            ValidationManager manager = new ValidationManager(serviceProvider);

            using (WorkflowCompilationContext.CreateScope(manager))
            {
                errors = ValidationHelpers.ValidateObject(manager, this.clonedRootActivity);
            }
            return(XomlCompilerHelper.MorphIntoFriendlyValidationErrors(errors));
        }
        public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
        {
            ValidationErrorCollection validationErrors = base.Validate(manager, obj);

            RuleSetReference ruleSetReference = obj as RuleSetReference;

            if (ruleSetReference == null)
            {
                string message = string.Format(CultureInfo.CurrentCulture, Messages.UnexpectedArgumentType, typeof(RuleSetReference).FullName, "obj");
                throw new ArgumentException(message, "obj");
            }
            Activity activity = manager.Context[typeof(Activity)] as Activity;

            if (activity == null)
            {
                string message = string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, typeof(Activity).Name);
                throw new InvalidOperationException(message);
            }
            PropertyValidationContext validationContext = manager.Context[typeof(PropertyValidationContext)] as PropertyValidationContext;

            if (validationContext == null)
            {
                string message = string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, typeof(PropertyValidationContext).Name);
                throw new InvalidOperationException(message);
            }
            if (!string.IsNullOrEmpty(ruleSetReference.RuleSetName))
            {
                RuleDefinitions   rules             = null;
                RuleSetCollection ruleSetCollection = null;

                CompositeActivity declaringActivity = Helpers.GetDeclaringActivity(activity);
                if (declaringActivity == null)
                {
                    declaringActivity = Helpers.GetRootActivity(activity) as CompositeActivity;
                }
                if (activity.Site != null)
                {
                    rules = ConditionHelper.Load_Rules_DT(activity.Site, declaringActivity);
                }
                else
                {
                    rules = ConditionHelper.Load_Rules_RT(declaringActivity);
                }

                if (rules != null)
                {
                    ruleSetCollection = rules.RuleSets;
                }

                if (ruleSetCollection == null || !ruleSetCollection.Contains(ruleSetReference.RuleSetName))
                {
                    string          message         = string.Format(CultureInfo.CurrentCulture, Messages.RuleSetNotFound, ruleSetReference.RuleSetName);
                    ValidationError validationError = new ValidationError(message, ErrorNumbers.Error_RuleSetNotFound);
                    validationError.PropertyName = GetFullPropertyName(manager) + "." + "RuleSetName";
                    validationErrors.Add(validationError);
                }
                else
                {
                    RuleSet actualRuleSet = ruleSetCollection[ruleSetReference.RuleSetName];

                    ITypeProvider typeProvider = (ITypeProvider)manager.GetService(typeof(ITypeProvider));

                    IDisposable localContextScope = (WorkflowCompilationContext.Current == null ? WorkflowCompilationContext.CreateScope(manager) : null);
                    try
                    {
                        RuleValidation validation = new RuleValidation(activity, typeProvider, WorkflowCompilationContext.Current.CheckTypes);
                        actualRuleSet.Validate(validation);
                        ValidationErrorCollection actualRuleSetErrors = validation.Errors;

                        if (actualRuleSetErrors.Count > 0)
                        {
                            string expressionPropertyName = GetFullPropertyName(manager);
                            string genericErrorMsg        = string.Format(CultureInfo.CurrentCulture, Messages.InvalidRuleSetExpression, expressionPropertyName);
                            int    errorNumber            = ErrorNumbers.Error_InvalidRuleSetExpression;

                            if (activity.Site != null)
                            {
                                foreach (ValidationError actualError in actualRuleSetErrors)
                                {
                                    ValidationError validationError = new ValidationError(actualError.ErrorText, errorNumber);
                                    validationError.PropertyName = expressionPropertyName + "." + "RuleSet Definition";
                                    validationErrors.Add(validationError);
                                }
                            }
                            else
                            {
                                foreach (ValidationError actualError in actualRuleSetErrors)
                                {
                                    ValidationError validationError = new ValidationError(genericErrorMsg + " " + actualError.ErrorText, errorNumber);
                                    validationError.PropertyName = expressionPropertyName;
                                    validationErrors.Add(validationError);
                                }
                            }
                        }
                        //
                    }
                    finally
                    {
                        if (localContextScope != null)
                        {
                            localContextScope.Dispose();
                        }
                    }
                }
            }
            else
            {
                string          message         = string.Format(CultureInfo.CurrentCulture, Messages.InvalidRuleSetName, "RuleSetReference");
                ValidationError validationError = new ValidationError(message, ErrorNumbers.Error_InvalidRuleSetName);
                validationError.PropertyName = GetFullPropertyName(manager) + "." + "RuleSetName";
                validationErrors.Add(validationError);
            }
            return(validationErrors);
        }
Example #6
0
        public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
        {
            if (manager == null)
            {
                throw new ArgumentNullException("manager");
            }
            if (manager.Context == null)
            {
                throw new InvalidOperationException(Messages.ContextStackMissing);
            }
            ValidationErrorCollection errors    = base.Validate(manager, obj);
            RuleConditionReference    reference = obj as RuleConditionReference;

            if (reference == null)
            {
                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.UnexpectedArgumentType, new object[] { typeof(RuleConditionReference).FullName, "obj" }), "obj");
            }
            Activity activity = manager.Context[typeof(Activity)] as Activity;

            if (activity == null)
            {
                throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, new object[] { typeof(Activity).Name }));
            }
            if (!(manager.Context[typeof(PropertyValidationContext)] is PropertyValidationContext))
            {
                throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, new object[] { typeof(PropertyValidationContext).Name }));
            }
            if (!string.IsNullOrEmpty(reference.ConditionName))
            {
                RuleDefinitions         definitions       = null;
                RuleConditionCollection conditions        = null;
                CompositeActivity       declaringActivity = Helpers.GetDeclaringActivity(activity);
                if (declaringActivity == null)
                {
                    declaringActivity = Helpers.GetRootActivity(activity) as CompositeActivity;
                }
                if (activity.Site != null)
                {
                    definitions = ConditionHelper.Load_Rules_DT(activity.Site, declaringActivity);
                }
                else
                {
                    definitions = ConditionHelper.Load_Rules_RT(declaringActivity);
                }
                if (definitions != null)
                {
                    conditions = definitions.Conditions;
                }
                if ((conditions == null) || !conditions.Contains(reference.ConditionName))
                {
                    ValidationError error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.ConditionNotFound, new object[] { reference.ConditionName }), 0x53e)
                    {
                        PropertyName = base.GetFullPropertyName(manager) + ".ConditionName"
                    };
                    errors.Add(error);
                    return(errors);
                }
                RuleCondition condition = conditions[reference.ConditionName];
                ITypeProvider service   = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
                using ((WorkflowCompilationContext.Current == null) ? WorkflowCompilationContext.CreateScope(manager) : null)
                {
                    RuleValidation validation = new RuleValidation(activity, service, WorkflowCompilationContext.Current.CheckTypes);
                    condition.Validate(validation);
                    ValidationErrorCollection errors2 = validation.Errors;
                    if (errors2.Count > 0)
                    {
                        string fullPropertyName = base.GetFullPropertyName(manager);
                        string errorText        = string.Format(CultureInfo.CurrentCulture, Messages.InvalidConditionExpression, new object[] { fullPropertyName });
                        int    errorNumber      = 0x558;
                        if (activity.Site != null)
                        {
                            ValidationError error2 = new ValidationError(errorText, errorNumber)
                            {
                                PropertyName = fullPropertyName + ".Expression"
                            };
                            errors.Add(error2);
                        }
                        else
                        {
                            foreach (ValidationError error3 in errors2)
                            {
                                ValidationError error4 = new ValidationError(errorText + " " + error3.ErrorText, errorNumber)
                                {
                                    PropertyName = fullPropertyName + ".Expression"
                                };
                                errors.Add(error4);
                            }
                        }
                    }
                    foreach (RuleCondition condition2 in conditions)
                    {
                        if ((condition2.Name == reference.ConditionName) && (condition2 != condition))
                        {
                            ValidationError error5 = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.DuplicateConditions, new object[] { reference.ConditionName }), 0x53f)
                            {
                                PropertyName = base.GetFullPropertyName(manager) + ".ConditionName"
                            };
                            errors.Add(error5);
                        }
                    }
                    return(errors);
                }
            }
            ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.InvalidConditionName, new object[] { "ConditionName" }), 0x540)
            {
                PropertyName = base.GetFullPropertyName(manager) + ".ConditionName"
            };

            errors.Add(item);
            return(errors);
        }
        internal void ValidateDefinition(Activity root, bool isNewType, ITypeProvider typeProvider)
        {
            if (!this.validateOnCreate)
            {
                return;
            }

            ValidationErrorCollection errors = new ValidationErrorCollection();

            // For validation purposes, create a type provider in the type case if the
            // host did not push one.
            if (typeProvider == null)
            {
                typeProvider = WorkflowRuntime.CreateTypeProvider(root);
            }

            // Validate that we are purely XAML.
            if (!isNewType)
            {
                if (!string.IsNullOrEmpty(root.GetValue(WorkflowMarkupSerializer.XClassProperty) as string))
                {
                    errors.Add(new ValidationError(ExecutionStringManager.XomlWorkflowHasClassName, ErrorNumbers.Error_XomlWorkflowHasClassName));
                }

                Queue compositeActivities = new Queue();
                compositeActivities.Enqueue(root);
                while (compositeActivities.Count > 0)
                {
                    Activity activity = compositeActivities.Dequeue() as Activity;

                    if (activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) != null)
                    {
                        errors.Add(new ValidationError(ExecutionStringManager.XomlWorkflowHasCode, ErrorNumbers.Error_XomlWorkflowHasCode));
                    }

                    CompositeActivity compositeActivity = activity as CompositeActivity;
                    if (compositeActivity != null)
                    {
                        foreach (Activity childActivity in compositeActivity.EnabledActivities)
                        {
                            compositeActivities.Enqueue(childActivity);
                        }
                    }
                }
            }

            ServiceContainer serviceContainer = new ServiceContainer();

            serviceContainer.AddService(typeof(ITypeProvider), typeProvider);

            ValidationManager validationManager = new ValidationManager(serviceContainer);

            using (WorkflowCompilationContext.CreateScope(validationManager))
            {
                foreach (Validator validator in validationManager.GetValidators(root.GetType()))
                {
                    foreach (ValidationError error in validator.Validate(validationManager, root))
                    {
                        if (!error.UserData.Contains(typeof(Activity)))
                        {
                            error.UserData[typeof(Activity)] = root;
                        }

                        errors.Add(error);
                    }
                }
            }
            if (errors.HasErrors)
            {
                throw new WorkflowValidationFailedException(ExecutionStringManager.WorkflowValidationFailure, errors);
            }
        }
Example #8
0
        public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
        {
            ValidationErrorCollection errors    = base.Validate(manager, obj);
            RuleSetReference          reference = obj as RuleSetReference;

            if (reference == null)
            {
                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Messages.UnexpectedArgumentType, new object[] { typeof(RuleSetReference).FullName, "obj" }), "obj");
            }
            Activity activity = manager.Context[typeof(Activity)] as Activity;

            if (activity == null)
            {
                throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, new object[] { typeof(Activity).Name }));
            }
            if (!(manager.Context[typeof(PropertyValidationContext)] is PropertyValidationContext))
            {
                throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Messages.ContextStackItemMissing, new object[] { typeof(PropertyValidationContext).Name }));
            }
            if (!string.IsNullOrEmpty(reference.RuleSetName))
            {
                RuleDefinitions   definitions       = null;
                RuleSetCollection ruleSets          = null;
                CompositeActivity declaringActivity = Helpers.GetDeclaringActivity(activity);
                if (declaringActivity == null)
                {
                    declaringActivity = Helpers.GetRootActivity(activity) as CompositeActivity;
                }
                if (activity.Site != null)
                {
                    definitions = ConditionHelper.Load_Rules_DT(activity.Site, declaringActivity);
                }
                else
                {
                    definitions = ConditionHelper.Load_Rules_RT(declaringActivity);
                }
                if (definitions != null)
                {
                    ruleSets = definitions.RuleSets;
                }
                if ((ruleSets == null) || !ruleSets.Contains(reference.RuleSetName))
                {
                    ValidationError error = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.RuleSetNotFound, new object[] { reference.RuleSetName }), 0x576)
                    {
                        PropertyName = base.GetFullPropertyName(manager) + ".RuleSetName"
                    };
                    errors.Add(error);
                    return(errors);
                }
                RuleSet       set     = ruleSets[reference.RuleSetName];
                ITypeProvider service = (ITypeProvider)manager.GetService(typeof(ITypeProvider));
                using ((WorkflowCompilationContext.Current == null) ? WorkflowCompilationContext.CreateScope(manager) : null)
                {
                    RuleValidation validation = new RuleValidation(activity, service, WorkflowCompilationContext.Current.CheckTypes);
                    set.Validate(validation);
                    ValidationErrorCollection errors2 = validation.Errors;
                    if (errors2.Count > 0)
                    {
                        string fullPropertyName = base.GetFullPropertyName(manager);
                        string str6             = string.Format(CultureInfo.CurrentCulture, Messages.InvalidRuleSetExpression, new object[] { fullPropertyName });
                        int    errorNumber      = 0x577;
                        if (activity.Site != null)
                        {
                            foreach (ValidationError error2 in errors2)
                            {
                                ValidationError error3 = new ValidationError(error2.ErrorText, errorNumber)
                                {
                                    PropertyName = fullPropertyName + ".RuleSet Definition"
                                };
                                errors.Add(error3);
                            }
                            return(errors);
                        }
                        foreach (ValidationError error4 in errors2)
                        {
                            ValidationError error5 = new ValidationError(str6 + " " + error4.ErrorText, errorNumber)
                            {
                                PropertyName = fullPropertyName
                            };
                            errors.Add(error5);
                        }
                    }
                    return(errors);
                }
            }
            ValidationError item = new ValidationError(string.Format(CultureInfo.CurrentCulture, Messages.InvalidRuleSetName, new object[] { "RuleSetReference" }), 0x578)
            {
                PropertyName = base.GetFullPropertyName(manager) + ".RuleSetName"
            };

            errors.Add(item);
            return(errors);
        }