public void Declare(LocationReference locationReference, Activity owner, ref IList<ValidationError> validationErrors)
 {
     if (locationReference.Name == null)
     {
         if (this.unnamedDeclarations == null)
         {
             this.unnamedDeclarations = new List<LocationReference>();
         }
         this.unnamedDeclarations.Add(locationReference);
     }
     else if (this.Declarations.ContainsKey(locationReference.Name))
     {
         string id = null;
         if (owner != null)
         {
             id = owner.Id;
         }
         ValidationError data = new ValidationError(System.Activities.SR.SymbolNamesMustBeUnique(locationReference.Name)) {
             Source = owner,
             Id = id
         };
         ActivityUtilities.Add<ValidationError>(ref validationErrors, data);
     }
     else
     {
         this.Declarations.Add(locationReference.Name, locationReference);
     }
 }
 internal bool InitializeRelationship(Activity parent, bool isPublic, ref IList<ValidationError> validationErrors)
 {
     if ((this.cacheId == parent.CacheId) && (this.Owner != null))
     {
         ValidationError data = new ValidationError(System.Activities.SR.VariableAlreadyInUseOnActivity(this.Name, parent.DisplayName, this.Owner.DisplayName), false, this.Name, parent);
         ActivityUtilities.Add<ValidationError>(ref validationErrors, data);
         return false;
     }
     this.Owner = parent;
     this.cacheId = parent.CacheId;
     this.IsPublic = isPublic;
     if (this.Default == null)
     {
         return true;
     }
     ActivityWithResult innerExpression = this.Default;
     if (innerExpression is Argument.IExpressionWrapper)
     {
         innerExpression = ((Argument.IExpressionWrapper) innerExpression).InnerExpression;
     }
     if (innerExpression.ResultType != base.Type)
     {
         ActivityUtilities.Add<ValidationError>(ref validationErrors, new ValidationError(System.Activities.SR.VariableExpressionTypeMismatch(this.Name, base.Type, innerExpression.ResultType), false, this.Name, parent));
     }
     return this.Default.InitializeRelationship(this, isPublic, ref validationErrors);
 }
 public ValidationErrorInfo(ValidationError validationError)
 {
     this.Id = validationError.Id;
     this.Message = validationError.Message;
     this.PropertyName = validationError.PropertyName;
     this.FileName = string.Empty;
     this.IsWarning = validationError.IsWarning;
 }
 public static void AddValidationError(NativeActivityContext context, ValidationError error)
 {
     List<ValidationError> list = context.Properties.Find("System.Activities.Validation.Constraint.ValidationErrorList") as List<ValidationError>;
     if (list == null)
     {
         throw FxTrace.Exception.AsError(new InvalidOperationException(System.Activities.SR.AddValidationErrorMustBeCalledFromConstraint(typeof(Constraint).Name)));
     }
     list.Add(error);
 }
 internal bool InitializeRelationship(Activity parent, ref IList<ValidationError> validationErrors)
 {
     if (this.cacheId == parent.CacheId)
     {
         ValidationError data = new ValidationError(System.Activities.SR.DelegateArgumentAlreadyInUseOnActivity(this.Name, parent.DisplayName, this.Owner.DisplayName), this.Owner);
         ActivityUtilities.Add<ValidationError>(ref validationErrors, data);
         return false;
     }
     this.Owner = parent;
     this.cacheId = parent.CacheId;
     return true;
 }
 private void ValidateExpressionSubtree(ActivityUtilities.ChildActivity childActivity, ActivityUtilities.ActivityCallStack parentChain)
 {
     if (childActivity.Activity.InternalCanInduceIdle)
     {
         Activity activity = childActivity.Activity;
         Activity expressionRoot = this.expressionRoot;
         RuntimeArgument boundRuntimeArgument = ActivityValidationServices.GetBoundRuntimeArgument(expressionRoot);
         ValidationError data = new ValidationError(System.Activities.SR.CanInduceIdleActivityInArgumentExpression(boundRuntimeArgument.Name, expressionRoot.Parent.DisplayName, activity.DisplayName), true, boundRuntimeArgument.Name, expressionRoot.Parent);
         ActivityUtilities.Add<ValidationError>(ref this.errors, data);
     }
 }
 private void ValidateElement(ActivityUtilities.ChildActivity childActivity, ActivityUtilities.ActivityCallStack parentChain)
 {
     Activity objA = childActivity.Activity;
     if (!this.settings.SingleLevel || object.ReferenceEquals(objA, this.rootToValidate))
     {
         if (this.settings.HasAdditionalConstraints)
         {
             bool suppressGetChildrenViolations = this.settings.OnlyUseAdditionalConstraints || this.settings.SingleLevel;
             for (Type type = objA.GetType(); type != null; type = type.BaseType)
             {
                 IList<Constraint> list;
                 if (this.settings.AdditionalConstraints.TryGetValue(type, out list))
                 {
                     ActivityValidationServices.RunConstraints(childActivity, parentChain, list, this.options, suppressGetChildrenViolations, ref this.errors);
                 }
                 if (type.IsGenericType)
                 {
                     IList<Constraint> list2;
                     Type genericTypeDefinition = type.GetGenericTypeDefinition();
                     if ((genericTypeDefinition != null) && this.settings.AdditionalConstraints.TryGetValue(genericTypeDefinition, out list2))
                     {
                         ActivityValidationServices.RunConstraints(childActivity, parentChain, list2, this.options, suppressGetChildrenViolations, ref this.errors);
                     }
                 }
             }
         }
         if (childActivity.Activity.IsExpressionRoot)
         {
             if (childActivity.Activity.HasNonEmptySubtree)
             {
                 this.expressionRoot = childActivity.Activity;
                 ActivityUtilities.FinishCachingSubtree(childActivity, parentChain, ProcessActivityTreeOptions.FullCachingOptions, new ActivityUtilities.ProcessActivityCallback(this.ValidateExpressionSubtree));
                 this.expressionRoot = null;
             }
             else if (childActivity.Activity.InternalCanInduceIdle)
             {
                 Activity activity = childActivity.Activity;
                 RuntimeArgument boundRuntimeArgument = ActivityValidationServices.GetBoundRuntimeArgument(activity);
                 ValidationError data = new ValidationError(System.Activities.SR.CanInduceIdleActivityInArgumentExpression(boundRuntimeArgument.Name, activity.Parent.DisplayName, activity.DisplayName), true, boundRuntimeArgument.Name, activity.Parent);
                 ActivityUtilities.Add<ValidationError>(ref this.errors, data);
             }
         }
     }
 }
 internal static void RunConstraints(ActivityUtilities.ChildActivity childActivity, ActivityUtilities.ActivityCallStack parentChain, IList<Constraint> constraints, ProcessActivityTreeOptions options, bool suppressGetChildrenViolations, ref IList<ValidationError> validationErrors)
 {
     if (constraints != null)
     {
         Activity activity = childActivity.Activity;
         LocationReferenceEnvironment parentEnvironment = activity.GetParentEnvironment();
         Dictionary<string, object> inputs = new Dictionary<string, object>(2);
         for (int i = 0; i < constraints.Count; i++)
         {
             Constraint workflow = constraints[i];
             if (workflow != null)
             {
                 object obj2;
                 inputs["ToValidate"] = activity;
                 ValidationContext context = new ValidationContext(childActivity, parentChain, options, parentEnvironment);
                 inputs["ToValidateContext"] = context;
                 IDictionary<string, object> dictionary2 = null;
                 try
                 {
                     dictionary2 = WorkflowInvoker.Invoke(workflow, inputs);
                 }
                 catch (Exception exception)
                 {
                     if (Fx.IsFatal(exception))
                     {
                         throw;
                     }
                     ValidationError data = new ValidationError(System.Activities.SR.InternalConstraintException(workflow.DisplayName, activity.GetType().FullName, activity.DisplayName, exception.ToString()), false) {
                         Source = activity,
                         Id = activity.Id
                     };
                     ActivityUtilities.Add<ValidationError>(ref validationErrors, data);
                 }
                 if ((dictionary2 != null) && dictionary2.TryGetValue("ViolationList", out obj2))
                 {
                     IList<ValidationError> list = (IList<ValidationError>) obj2;
                     if (list.Count > 0)
                     {
                         Activity activity2;
                         if (validationErrors == null)
                         {
                             validationErrors = new List<ValidationError>();
                         }
                         string str = GenerateValidationErrorPrefix(childActivity.Activity, parentChain, out activity2);
                         for (int j = 0; j < list.Count; j++)
                         {
                             ValidationError item = list[j];
                             item.Source = activity2;
                             item.Id = activity2.Id;
                             if (!string.IsNullOrEmpty(str))
                             {
                                 item.Message = str + item.Message;
                             }
                             validationErrors.Add(item);
                         }
                     }
                 }
                 if (!suppressGetChildrenViolations)
                 {
                     context.AddGetChildrenErrors(ref validationErrors);
                 }
             }
         }
     }
 }
 internal static void RunConstraints(ActivityUtilities.ChildActivity childActivity, ActivityUtilities.ActivityCallStack parentChain, IList <Constraint> constraints, ProcessActivityTreeOptions options, bool suppressGetChildrenViolations, ref IList <ValidationError> validationErrors)
 {
     if (constraints != null)
     {
         Activity activity = childActivity.Activity;
         LocationReferenceEnvironment parentEnvironment = activity.GetParentEnvironment();
         Dictionary <string, object>  inputs            = new Dictionary <string, object>(2);
         for (int i = 0; i < constraints.Count; i++)
         {
             Constraint workflow = constraints[i];
             if (workflow != null)
             {
                 object obj2;
                 inputs["ToValidate"] = activity;
                 ValidationContext context = new ValidationContext(childActivity, parentChain, options, parentEnvironment);
                 inputs["ToValidateContext"] = context;
                 IDictionary <string, object> dictionary2 = null;
                 try
                 {
                     dictionary2 = WorkflowInvoker.Invoke(workflow, inputs);
                 }
                 catch (Exception exception)
                 {
                     if (Fx.IsFatal(exception))
                     {
                         throw;
                     }
                     ValidationError data = new ValidationError(System.Activities.SR.InternalConstraintException(workflow.DisplayName, activity.GetType().FullName, activity.DisplayName, exception.ToString()), false)
                     {
                         Source = activity,
                         Id     = activity.Id
                     };
                     ActivityUtilities.Add <ValidationError>(ref validationErrors, data);
                 }
                 if ((dictionary2 != null) && dictionary2.TryGetValue("ViolationList", out obj2))
                 {
                     IList <ValidationError> list = (IList <ValidationError>)obj2;
                     if (list.Count > 0)
                     {
                         Activity activity2;
                         if (validationErrors == null)
                         {
                             validationErrors = new List <ValidationError>();
                         }
                         string str = GenerateValidationErrorPrefix(childActivity.Activity, parentChain, out activity2);
                         for (int j = 0; j < list.Count; j++)
                         {
                             ValidationError item = list[j];
                             item.Source = activity2;
                             item.Id     = activity2.Id;
                             if (!string.IsNullOrEmpty(str))
                             {
                                 item.Message = str + item.Message;
                             }
                             validationErrors.Add(item);
                         }
                     }
                 }
                 if (!suppressGetChildrenViolations)
                 {
                     context.AddGetChildrenErrors(ref validationErrors);
                 }
             }
         }
     }
 }
        // Mark a single "child has an error" on a parent
        private void MarkParent(ValidationError validationError, object errorParent)
        {
            ValidationState childValidationState = GetValidationState(validationError);
            ValidationErrorState currentError;
            if (!this.ValidationErrors.TryGetValue(errorParent, out currentError))
            {
                currentError = ChildInvalidError();
                this.ValidationErrors.Add(errorParent, currentError);
            }

            if (currentError.ValidationState < childValidationState)
            {
                currentError.ValidationState = childValidationState;
            }

            this.NotifyValidationPropertiesChanged(errorParent);
        }
 // Mark a single error on the culprit
 private void MarkCulprit(object errorSource, ValidationError validationError)
 {
     ValidationErrorState currentError;
     if (!this.ValidationErrors.TryGetValue(errorSource, out currentError))
     {
         currentError = new ValidationErrorState(new List<string>(), ValidationState.Valid);
         this.ValidationErrors.Add(errorSource, currentError);
     }
     MergeValidationError(currentError, validationError);
     this.NotifyValidationPropertiesChanged(errorSource);
 }
        // Mark a single error including its parent chain
        private void MarkError(ValidationError validationError, List<object> errorSourcePath)
        {
            object errorSource = errorSourcePath[0];
            this.MarkCulprit(errorSource, validationError);

            // Intentionally skipping the zeroth errorSourcePath because that is the culprit and is marked above.
            for (int errorSourcePathIndex = 1; errorSourcePathIndex < errorSourcePath.Count; errorSourcePathIndex++)
            {
                this.MarkParent(validationError, errorSourcePath[errorSourcePathIndex]);
            }

            foreach (object parent in this.GetParentChainWithSource(validationError.Source))
            {
                this.MarkParent(validationError, parent);
            }
        }
Ejemplo n.º 13
0
            private void ValidateElement(ActivityUtilities.ChildActivity childActivity, ActivityUtilities.ActivityCallStack parentChain)
            {
                var toValidate = childActivity.Activity;

                if (!this.settings.SingleLevel || object.ReferenceEquals(toValidate, this.rootToValidate))
                {
                    // 0. Open time violations are captured by the CacheMetadata walk.

                    // 1. Argument validations are done by the CacheMetadata walk.

                    // 2. Build constraints are done by the CacheMetadata walk.

                    // 3. Then do policy constraints
                    if (this.settings.HasAdditionalConstraints && childActivity.CanBeExecuted && parentChain.WillExecute)
                    {
                        var suppressGetChildrenViolations = this.settings.OnlyUseAdditionalConstraints || this.settings.SingleLevel;

                        var currentType = toValidate.GetType();

                        while (currentType != null)
                        {
                            if (this.settings.AdditionalConstraints.TryGetValue(currentType, out var policyConstraints))
                            {
                                RunConstraints(childActivity, parentChain, policyConstraints, this.options, suppressGetChildrenViolations, ref this.errors);
                            }

                            if (currentType.IsGenericType)
                            {
                                var genericDefinitionType = currentType.GetGenericTypeDefinition();
                                if (genericDefinitionType != null)
                                {
                                    if (this.settings.AdditionalConstraints.TryGetValue(genericDefinitionType, out var genericTypePolicyConstraints))
                                    {
                                        RunConstraints(childActivity, parentChain, genericTypePolicyConstraints, this.options, suppressGetChildrenViolations, ref this.errors);
                                    }
                                }
                            }
                            currentType = currentType.BaseType;
                        }
                    }

                    //4. Validate if the argument expression subtree contains an activity that can induce idle.
                    if (childActivity.Activity.IsExpressionRoot)
                    {
                        if (childActivity.Activity.HasNonEmptySubtree)
                        {
                            this.expressionRoot = childActivity.Activity;
                            // Back-compat: In Dev10 we always used ProcessActivityTreeOptions.FullCachingOptions here, and ignored this.options.
                            // So we need to continue to do that, unless the new Dev11 flag SkipRootConfigurationValidation is passed.
                            var options = this.options.SkipRootConfigurationValidation ? this.options : ProcessActivityTreeOptions.FullCachingOptions;
                            ActivityUtilities.FinishCachingSubtree(childActivity, parentChain, options, ValidateExpressionSubtree);
                            this.expressionRoot = null;
                        }
                        else if (childActivity.Activity.InternalCanInduceIdle)
                        {
                            var activity        = childActivity.Activity;
                            var runtimeArgument = GetBoundRuntimeArgument(activity);
                            var error           = new ValidationError(SR.CanInduceIdleActivityInArgumentExpression(runtimeArgument.Name, activity.Parent.DisplayName, activity.DisplayName), true, runtimeArgument.Name, activity.Parent);
                            ActivityUtilities.Add(ref this.errors, error);
                        }
                    }
                }
            }
Ejemplo n.º 14
0
        internal static void RunConstraints(ActivityUtilities.ChildActivity childActivity, ActivityUtilities.ActivityCallStack parentChain, IList <Constraint> constraints, ProcessActivityTreeOptions options, bool suppressGetChildrenViolations, ref IList <ValidationError> validationErrors)
        {
            if (constraints != null)
            {
                var toValidate = childActivity.Activity;

                var environment = toValidate.GetParentEnvironment();

                var inputDictionary = new Dictionary <string, object>(2);

                for (var constraintIndex = 0; constraintIndex < constraints.Count; constraintIndex++)
                {
                    var constraint = constraints[constraintIndex];

                    // there may be null entries here
                    if (constraint == null)
                    {
                        continue;
                    }

                    inputDictionary[Constraint.ToValidateArgumentName] = toValidate;
                    var validationContext = new ValidationContext(childActivity, parentChain, options, environment);
                    inputDictionary[Constraint.ToValidateContextArgumentName] = validationContext;
                    IDictionary <string, object> results = null;

                    try
                    {
                        results = WorkflowInvoker.Invoke(constraint, inputDictionary);
                    }
                    catch (Exception e)
                    {
                        if (Fx.IsFatal(e))
                        {
                            throw;
                        }

                        var constraintExceptionValidationError = new ValidationError(SR.InternalConstraintException(constraint.DisplayName, toValidate.GetType().FullName, toValidate.DisplayName, e.ToString()), false)
                        {
                            Source = toValidate,
                            Id     = toValidate.Id
                        };

                        ActivityUtilities.Add(ref validationErrors, constraintExceptionValidationError);
                    }

                    if (results != null)
                    {
                        if (results.TryGetValue(Constraint.ValidationErrorListArgumentName, out var resultValidationErrors))
                        {
                            var validationErrorList = (IList <ValidationError>)resultValidationErrors;

                            if (validationErrorList.Count > 0)
                            {
                                if (validationErrors == null)
                                {
                                    validationErrors = new List <ValidationError>();
                                }

                                var prefix = ActivityValidationServices.GenerateValidationErrorPrefix(childActivity.Activity, parentChain, options, out var source);

                                for (var validationErrorIndex = 0; validationErrorIndex < validationErrorList.Count; validationErrorIndex++)
                                {
                                    var validationError = validationErrorList[validationErrorIndex];

                                    validationError.Source = source;
                                    validationError.Id     = source.Id;
                                    if (!string.IsNullOrEmpty(prefix))
                                    {
                                        validationError.Message = prefix + validationError.Message;
                                    }
                                    validationErrors.Add(validationError);
                                }
                            }
                        }
                    }

                    if (!suppressGetChildrenViolations)
                    {
                        validationContext.AddGetChildrenErrors(ref validationErrors);
                    }
                }
            }
        }
        internal bool InitializeRelationship(Activity parent, ref IList<ValidationError> validationErrors)
        {
            if (this.cacheId == parent.CacheId)
            {
                Fx.Assert(this.Owner != null, "must have an owner here");
                ValidationError validationError = new ValidationError(SR.DelegateArgumentAlreadyInUseOnActivity(this.Name, parent.DisplayName, this.Owner.DisplayName), this.Owner);
                ActivityUtilities.Add(ref validationErrors, validationError);

                // Get out early since we've already initialized this argument.
                return false;
            }

            this.Owner = parent;
            this.cacheId = parent.CacheId;

            return true;
        }
 private static ValidationState GetValidationState(ValidationError validationError)
 {
     return validationError.IsWarning ? ValidationState.Warning : ValidationState.Error;
 }
        private static void MergeValidationError(ValidationErrorState originalError, ValidationError newError)
        {
            if (originalError.ValidationState == ValidationState.ChildInvalid)
            {
                // If original error is due to child's issue, clear the error list, 
                // as we don't care about its child's issues anymore and want to add its own issues.
                originalError.ErrorMessages.Clear();
            }

            ValidationState errorState = GetValidationState(newError);
            if (originalError.ValidationState < errorState)
            {
                // Promote to the higher level of violation.
                originalError.ValidationState = errorState;
            }

            if (newError.IsWarning)
            {
                originalError.ErrorMessages.Add(string.Format(CultureInfo.CurrentUICulture, SR.WarningFormat, newError.Message));
            }
            else
            {
                originalError.ErrorMessages.Add(newError.Message);
            }
        }
        public void Declare(LocationReference locationReference, Activity owner, ref IList<ValidationError> validationErrors)
        {
            Fx.Assert(locationReference != null, "Must not be null");

            if (locationReference.Name == null)
            {
                if (this.unnamedDeclarations == null)
                {
                    this.unnamedDeclarations = new List<LocationReference>();
                }

                this.unnamedDeclarations.Add(locationReference);
            }
            else
            {
                if (this.Declarations.ContainsKey(locationReference.Name))
                {
                    string id = null;

                    if (owner != null)
                    {
                        id = owner.Id;
                    }

                    ValidationError validationError = new ValidationError(SR.SymbolNamesMustBeUnique(locationReference.Name))
                    {
                        Source = owner,
                        Id = id
                    };

                    ActivityUtilities.Add(ref validationErrors, validationError);
                }
                else
                {
                    this.Declarations.Add(locationReference.Name, locationReference);
                }
            }
        }
        private static string GenerateExceptionString(IList <ValidationError> validationErrors, ExceptionReason reason)
        {
            // 4096 is an arbitrary constant.  Currently clipped by character count (not bytes).
            const int maxExceptionStringSize = 4096;

            StringBuilder exceptionMessageBuilder = null;

            for (int i = 0; i < validationErrors.Count; i++)
            {
                ValidationError validationError = validationErrors[i];

                if (!validationError.IsWarning)
                {
                    // create the common exception string
                    if (exceptionMessageBuilder == null)
                    {
                        exceptionMessageBuilder = new StringBuilder();

                        switch (reason)
                        {
                        case ExceptionReason.InvalidTree:
                            exceptionMessageBuilder.Append(SR.ErrorsEncounteredWhileProcessingTree);
                            break;

                        case ExceptionReason.InvalidNonNullInputs:
                            exceptionMessageBuilder.Append(SR.RootArgumentViolationsFound);
                            break;

                        case ExceptionReason.InvalidNullInputs:
                            exceptionMessageBuilder.Append(SR.RootArgumentViolationsFoundNoInputs);
                            break;
                        }
                    }

                    string activityName = null;

                    if (validationError.Source != null)
                    {
                        activityName = validationError.Source.DisplayName;
                    }
                    else
                    {
                        activityName = "<UnknownActivity>";
                    }

                    exceptionMessageBuilder.AppendLine();
                    exceptionMessageBuilder.Append(string.Format("'{0}': {1}", activityName, validationError.Message));

                    if (exceptionMessageBuilder.Length > maxExceptionStringSize)
                    {
                        break;
                    }
                }
            }

            string exceptionString = null;

            if (exceptionMessageBuilder != null)
            {
                exceptionString = exceptionMessageBuilder.ToString();

                if (exceptionString.Length > maxExceptionStringSize)
                {
                    string snipNotification = SR.TooManyViolationsForExceptionMessage;

                    exceptionString  = exceptionString.Substring(0, maxExceptionStringSize - snipNotification.Length);
                    exceptionString += snipNotification;
                }
            }

            return(exceptionString);
        }