/// <summary>
 /// Initializes a new instance of the <see cref="StopIfNotFieldExists"/> class.
 /// </summary>
 /// <param name="primaryProperty">Primary property for this rule.</param>
 public StopIfNotFieldExists(IPropertyInfo primaryProperty)
   : base(primaryProperty)
 {
   if (InputProperties == null)
     InputProperties = new List<IPropertyInfo>();
   InputProperties.Add(primaryProperty);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="FrequencyHoursShouldBeGreaterThanZeroRule"/> class.
 /// </summary>
 /// <param name="hoursProperty">The hours property.</param>
 /// <param name="frequencyTypePorperty">The frequency type property.</param>
 /// <param name="frequencyFieldName">Name of the frequency field.</param>
 public FrequencyHoursShouldBeGreaterThanZeroRule(IPropertyInfo hoursProperty, IPropertyInfo frequencyTypePorperty, string frequencyFieldName) : base(hoursProperty)
 {
     InputProperties = new List<IPropertyInfo> { hoursProperty, frequencyTypePorperty };
     _frequencyTypeProperty = frequencyTypePorperty;
     _frequencyFieldName = frequencyFieldName;
     RuleUri.AddQueryParameter("frequencyFieldName", frequencyFieldName);
 }

        public DefaultActivityStatus(IPropertyInfo activityIdProperty, IPropertyInfo activityStatusProperty, IPropertyInfo approvedByIdProperty)
            : base(activityIdProperty)
        {
            if (activityIdProperty == null)
            {
                throw new ArgumentException("activityIdProperty cannot be null.");
            }
            if (activityStatusProperty == null)
            {
                throw new ArgumentException("activityStatusProperty cannot be null.");
            }
            if (approvedByIdProperty == null)
            {
                throw new ArgumentException("approvedByIdProperty cannot be null.");
            }
            if (activityIdProperty.Type != typeof(int))
            {
                throw new ArgumentException("activityIdProperty must be an int.");
            }
            if (activityStatusProperty.Type != typeof(ActivitySubmissionStatus))
            {
                throw new ArgumentException("activityStatusProperty must be a Common.Enums.ActivitySubmissionStatus.");
            }
            if (approvedByIdProperty.Type != typeof(int))
            {
                throw new ArgumentException("approvedByIdProperty must be a Common.Enums.ActivitySubmissionStatus.");
            }

            this.StatusName = activityStatusProperty.Name;
            this.ApprovedByIdName = approvedByIdProperty.Name;
            this.InputProperties = new List<IPropertyInfo> { activityIdProperty, activityStatusProperty, approvedByIdProperty };
            this.AffectedProperties.Add(activityStatusProperty);
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="GreaterThanOrEqual"/> class.
 /// </summary>
 /// <param name="primaryProperty">
 /// The primary property.
 /// </param>
 /// <param name="compareToProperty">
 /// The compare to property.
 /// </param>
 public GreaterThanOrEqual(IPropertyInfo primaryProperty, IPropertyInfo compareToProperty)
   : base(primaryProperty)
 {
   CompareTo = compareToProperty;
   InputProperties = new List<IPropertyInfo>() { primaryProperty, compareToProperty };
   this.RuleUri.AddQueryParameter("compareTo", compareToProperty.Name);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ResultFieldValidationRule"/> class.
 /// </summary>
 /// <param name="idProperty">The identifier property.</param>
 /// <param name="resultProperty">The result property.</param>
 /// <param name="resultListProperty">The result list property.</param>
 public ResultFieldValidationRule(IPropertyInfo idProperty, IPropertyInfo resultProperty, IPropertyInfo resultListProperty)
     : base(idProperty)
 {
     _resultProperty = resultProperty;
     _resultListProperty = resultListProperty;
     InputProperties = new List<IPropertyInfo> { idProperty, resultProperty, resultListProperty };
 }

 public AnyRequired(IPropertyInfo primaryProperty, params IPropertyInfo[] additionalProperties)
   : base(primaryProperty)
 {
   InputProperties = new List<IPropertyInfo>() {primaryProperty};
   InputProperties.AddRange(additionalProperties);
   this.RuleUri.AddQueryParameter("any", string.Join(",", additionalProperties.Select(p => p.Name).ToArray()));
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="PropertyRule"/> class.
 /// </summary>
 /// <param name="propertyInfo">The property info.</param>
 protected PropertyRule(IPropertyInfo propertyInfo)
     : base(propertyInfo)
 {
     CanRunAsAffectedProperty = true;
       CanRunOnServer = true;
       CanRunInCheckRules = true;
 }

 public CollectionMinimumCountBusinessRule(IPropertyInfo collectionProperty, int minCount)
     : base(collectionProperty)
 {
     PrimaryProperty = collectionProperty;
       InputProperties = new List<IPropertyInfo>() { collectionProperty };
       _MinCount = minCount;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="AsyncLookupRule"/> class.
 /// </summary>
 /// <param name="primaryProperty">Primary property for this rule.</param>
 protected AsyncLookupRule(IPropertyInfo primaryProperty) : base(primaryProperty)
 {
   IsAsync = true;
   CanRunAsAffectedProperty = false;
   CanRunInCheckRules = false;
   CanRunOnServer = false;
 }

 public SetStateName(IPropertyInfo stateIdProperty, IPropertyInfo stateNameProperty)
   : base(stateIdProperty)
 {
   StateName = stateNameProperty;
   InputProperties = new List<IPropertyInfo> { stateIdProperty };
   AffectedProperties.Add(StateName);
 }

        public NoDuplicates(IPropertyInfo primaryProperty, IPropertyInfo idProperty, CheckForDuplicates duplicateCommand)
            : base(primaryProperty)
        {
            if (primaryProperty == null)
            {
                throw new ArgumentException("primaryProperty cannot be null.");
            }
            if (idProperty == null)
            {
                throw new ArgumentException("idProperty cannot be null.");
            }
            if (duplicateCommand == null)
            {
                throw new ArgumentException("duplicateCommand cannot be null.");
            }
            if (primaryProperty.Type != typeof(string))
            {
                throw new ArgumentException("primaryProperty must be a string.");
            }
            if (idProperty.Type != typeof(int))
            {
                throw new ArgumentException("idProperty must be an int.");
            }

            this.IdPropertyName = idProperty.Name;
            this.InputProperties = new List<IPropertyInfo> { primaryProperty, idProperty };
            this.DuplicateCommand = duplicateCommand;
        }

            /// <summary>
            /// Initializes a new instance of the <see cref="ParameterNameIsRequired"/> class.
            /// </summary>
            /// <param name="systemParameterListProperty">The system parameter list property.</param>
            public ParameterNameIsRequired(IPropertyInfo systemParameterListProperty): base(systemParameterListProperty)
            {
                this.InputProperties = new List<IPropertyInfo> {systemParameterListProperty};

                _required = new Csla.Rules.CommonRules.Required(systemParameterListProperty);
                RuleUri.AddQueryParameter("rule", System.Uri.EscapeUriString(_required.RuleName));
            }

 public PropertyXCanNotBeEmptyIfPropertyYHasValue(IPropertyInfo primaryProperty, IPropertyInfo dependentProperty)
     : base(primaryProperty)
 {
     InputProperties = new List<IPropertyInfo> {primaryProperty, dependentProperty};
     DependentProperty = dependentProperty;
     MessageText = ResourcesValidation.PropertyXCantBeEmptyIfPropertyYHasValue;
 }

        public DefaultBadgeStatus(IPropertyInfo badgeTypeProperty, IPropertyInfo badgeStatusProperty, IPropertyInfo approvedByIdProperty)
            : base(badgeTypeProperty)
        {
            if (badgeTypeProperty == null)
            {
                throw new ArgumentException("badgeIdProperty cannot be null.");
            }
            if (badgeStatusProperty == null)
            {
                throw new ArgumentException("badgeStatusProperty cannot be null.");
            }
            if (approvedByIdProperty == null)
            {
                throw new ArgumentException("approvedByIdProperty cannot be null.");
            }
            if (badgeTypeProperty.Type != typeof(BadgeType))
            {
                throw new ArgumentException("badgeTypeProperty must be a Common.Enums.BadgeType.");
            }
            if (badgeStatusProperty.Type != typeof(BadgeStatus))
            {
                throw new ArgumentException("badgeStatusProperty must be a Common.Enums.BadgeStatus.");
            }
            if (approvedByIdProperty.Type != typeof(int))
            {
                throw new ArgumentException("approvedByIdProperty must be an int.");
            }

            this.StatusName = badgeStatusProperty.Name;
            this.ApprovedByIdName = approvedByIdProperty.Name;
            this.InputProperties = new List<IPropertyInfo> { badgeTypeProperty, badgeStatusProperty, approvedByIdProperty };
            this.AffectedProperties.Add(badgeStatusProperty);
        }

 private bool IsAlreadyLoadingProperty(IPropertyInfo property)
 {
   lock (_syncRoot)
   {
     return _loading.Any(l => l.Property == property);
   }
 }

        internal UnresolvedPropertyInfo(IPropertyInfo adapter)
        {
            if (adapter == null)
                throw new ArgumentNullException("adapter");

            this.adapter = adapter;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="RequiredFieldRule"/> class. 
 /// </summary>
 /// <param name="primaryProperty">
 /// Primary property for this rule.
 /// </param>
 public RequiredFieldRule(IPropertyInfo primaryProperty)
     : base(primaryProperty)
 {
     // Don't add the primary property to the InputProperties collection so that
     // we don't load the property value if the property is not required in current configuration.
     // This way we can make some heavy fields lazy loaded, for example multi cross-references.
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="CollapseWhiteSpace"/> class.
        /// </summary>
        /// <param name="primaryProperty">The primary property.</param>
        public CollapseWhiteSpace(IPropertyInfo primaryProperty)
            : base(primaryProperty)
        {
            InputProperties = new List<IPropertyInfo> {primaryProperty};

            CanRunOnServer = false;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="CalcSum"/> class.
 /// </summary>
 /// <param name="primaryProperty">
 /// The primary property.
 /// </param>
 /// <param name="inputProperties">
 /// The input properties.
 /// </param>
 public CalcSum(IPropertyInfo primaryProperty, params IPropertyInfo[] inputProperties)
   : base(primaryProperty)
 {
   InputProperties = new List<IPropertyInfo>();
   InputProperties.AddRange(inputProperties);
   this.RuleUri.AddQueryParameter("input", string.Join(",", inputProperties.Select(p => p.Name).ToArray()));
   CanRunOnServer = false;
 }

        public IntegerLessThanOtherInteger(IPropertyInfo intFirst, IPropertyInfo intSecond)
            : base(intFirst)
        {
            InputProperties = new List<IPropertyInfo> {intFirst, intSecond};

            IntSecondProperty = intSecond;
            AffectedProperties.Add(intSecond);
        }