protected static void CheckRule(IBusinessRule rule)
{
if (rule.IsFailed())
{
throw new BusinessRuleValidationException(rule.Message);
}
}
protected static void CheckRule(IBusinessRule rule)
{
if (rule.IsBroken())
{
throw new BusinessRuleValidationException(rule);
}
}
/// <summary>
///
/// </summary>
/// <param name="businessRule"></param>
protected static void ValidateBusinessRule(IBusinessRule businessRule)
{
if (businessRule.IsViolated())
{
throw new BusinessRuleViolationException(businessRule);
}
}
protected void CheckRule(IBusinessRule rule)
{
if (rule != null)
{
rule.CheckIsBroken();
}
}
/// <summary>
/// Creates an instance of the object.
/// </summary>
/// <param name="rule">Instance of rule.</param>
/// <param name="property">Property to which the rule is attached.</param>
/// <param name="priority">Rule priority.</param>
internal RuleMethod(IBusinessRule rule, Core.IPropertyInfo property, int priority)
{
Rule = rule;
PrimaryProperty = property;
Priority = priority;
RuleName = new Rules.RuleUri(Rule, PrimaryProperty).ToString();
}
protected void CheckRule(IBusinessRule rule)
{
if (rule.isBroken())
{
throw rule.Exception;
}
}
/// <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));
}
/// <summary>
/// Creates an instance of the object.
/// </summary>
/// <param name="rule">Instance of rule.</param>
/// <param name="property">Property to which the rule is attached.</param>
/// <param name="priority">Rule priority.</param>
internal RuleMethod(IBusinessRule rule, Core.IPropertyInfo property, int priority)
{
Rule = rule;
PrimaryProperty = property;
Priority = priority;
RuleName = new Rules.RuleUri(Rule, PrimaryProperty).ToString();
}
/// <summary>
/// Creates a RuleContext instance for testing.
/// </summary>
/// <param name="completeHandler">Callback for async rule.</param>
/// <param name="rule">Reference to the rule object.</param>
/// <param name="target">Target business object.</param>
/// <param name="inputPropertyValues">Input property values used by the rule.</param>
public RuleContext(Action <RuleContext> completeHandler, IBusinessRule rule, object target, Dictionary <Csla.Core.IPropertyInfo, object> inputPropertyValues)
: this(completeHandler)
{
Rule = rule;
Target = target;
InputPropertyValues = inputPropertyValues;
}
private void CheckRule(IBusinessRule rule)
{
if (rule.IsBroken())
{
throw new ApplicationException(rule.ExceptionResourceKey);
}
}
protected void CheckRule(IBusinessRule rule, Action throwProperException)
{
if (rule.IsBroken())
{
throwProperException.Invoke();
}
}
public void CheckRule(IBusinessRule rule)
{
if (!rule.IsValid())
{
throw new BrokenBusinessRuleException(rule);
}
}
/// <summary>
/// Determines whether this rule can run the specified context mode.
/// </summary>
/// <param name="rule">The rule.</param>
/// <param name="contextMode">The context mode.</param>
/// <returns>
/// <c>true</c> if this instance [can run rule] the specified context mode; otherwise, <c>false</c>.
/// </returns>
internal static bool CanRunRule(IBusinessRule rule, RuleContextModes contextMode)
{
// default then just return true
if (rule.RunMode == RunModes.Default)
{
return(true);
}
bool canRun = true;
if ((contextMode & RuleContextModes.AsAffectedPoperty) > 0)
{
canRun = canRun & (rule.RunMode & RunModes.DenyAsAffectedProperty) == 0;
}
if ((rule.RunMode & RunModes.DenyOnServerSidePortal) > 0)
{
canRun = canRun & ApplicationContext.LogicalExecutionLocation != ApplicationContext.LogicalExecutionLocations.Server;
}
if ((contextMode & RuleContextModes.CheckRules) > 0)
{
canRun = canRun & (rule.RunMode & RunModes.DenyCheckRules) == 0;
}
return(canRun);
}
protected void CheckRule(IBusinessRule businessRule)
{
if (businessRule.IsBroken())
{
throw new BusinessRuleValidationException(businessRule);
}
}
protected void CheckRule(IBusinessRule rule)
{
if (rule.IsBroken())
{
throw new BusinessRuleViolationException(rule);
}
}
protected static void CheckRule(IBusinessRule rule)
{
if (rule.IsBroken())
{
throw new DomainException(rule.Message);
}
}
public void Add(IBusinessRule ruleToAdd)
{
if (Contains(ruleToAdd))
{
return;
}
_rules.Add(ruleToAdd);
}
public RecommendationContentService(IRepository repository, IUserService userService, IBusinessRule businessRules)
{
_repository = repository;
_userService = userService;
_businessRules = businessRules;
}
/// <summary>
/// Executes the inner rule from the outer rules context.
/// Creates a chained context and if CanRunRule will execute the inner rule.
/// </summary>
/// <param name="innerRule">The inner rule.</param>
public void ExecuteRule(IBusinessRule innerRule)
{
var chainedContext = GetChainedContext(innerRule);
if (BusinessRules.CanRunRule(innerRule, chainedContext.ExecuteContext))
{
innerRule.Execute(chainedContext);
}
}
protected static bool CheckRule(IBusinessRule rule)
{
if (rule.IsBroken())
{
throw new BusinessRuleValidationException(rule);
}
return(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="LDAPValidationRule"/> class.
/// </summary>
/// <param name="ldapServerPath">The LDAP server path.</param>
/// <param name="useLDAPForLogin">The use LDAP for login.</param>
public LDAPValidationRule(IPropertyInfo ldapServerPath, IPropertyInfo useLDAPForLogin)
: base(ldapServerPath)
{
_useLDAPForLogin = useLDAPForLogin;
InputProperties = new List<IPropertyInfo> { ldapServerPath, useLDAPForLogin };
_ldapServerPathRequired = new Csla.Rules.CommonRules.Required(ldapServerPath);
RuleUri.AddQueryParameter("rule", System.Uri.EscapeUriString(_ldapServerPathRequired.RuleName));
}
/// <summary>
/// Initializes a new instance of the <see cref="LDAPSearchFilterValidationRule"/> class.
/// </summary>
/// <param name="ldapSearchFilter">The LDAP search filter.</param>
/// <param name="ldapServerType">The LDAP server type.</param>
public LDAPSearchFilterValidationRule(IPropertyInfo ldapSearchFilter, IPropertyInfo ldapServerType)
: base(ldapSearchFilter)
{
_ldapServerType = ldapServerType;
InputProperties = new List<IPropertyInfo> { ldapSearchFilter, ldapServerType };
_ldapSearchFilterRequired = new Csla.Rules.CommonRules.Required(ldapSearchFilter);
RuleUri.AddQueryParameter("rule", System.Uri.EscapeUriString(_ldapSearchFilterRequired.RuleName));
}
public override bool Equals(object obj)
{
IBusinessRule <T> rule = obj as IBusinessRule <T>;
if (rule != null)
{
return(this.Name.Equals(rule.Name));
}
return(true);
}
protected static void CheckRule(IBusinessRule rule)
{
if (rule.IsBroken())
{
// TODO:
// throw new DomainValidationException(rule);
throw new NotImplementedException();
}
}
/// <summary>
/// Adds a <see cref="IBusinessRule{TEntity}"/> instance to the rules evaluator.
/// </summary>
/// <param name="rule">The <see cref="IBusinessRule{TEntity}"/> instance to add.</param>
/// <param name="ruleName">string. The unique name assigned to the business rule.</param>
protected void AddRule(string ruleName, IBusinessRule <TEntity> rule)
{
Guard.Against <ArgumentNullException>(rule == null,
"Cannot add a null rule instance. Expected a non null reference.");
Guard.Against <ArgumentNullException>(string.IsNullOrEmpty(ruleName),
"Cannot add a rule with an empty or null rule name.");
Guard.Against <ArgumentException>(_ruleSets.ContainsKey(ruleName),
"Another rule with the same name already exists. Cannot add duplicate rules.");
_ruleSets.Add(ruleName, rule);
}
protected override void Context()
{
_ruleForValue = A.Fake <IBusinessRule>();
_anotherRule = A.Fake <IBusinessRule>();
A.CallTo(() => _ruleForValue.IsRuleFor("Value")).Returns(true);
A.CallTo(() => _anotherRule.IsRuleFor("Value")).Returns(false);
_businessRuleSet = new BusinessRuleSet(_ruleForValue, _anotherRule);
_parameter = A.Fake <IParameter>();
A.CallTo(() => _parameter.Rules).Returns(_businessRuleSet);
sut = new ParameterDTO(_parameter);
}
/// <summary>
/// Creates a RuleContext instance for testing.
/// </summary>
/// <param name="completeHandler">Callback for async rule.</param>
/// <param name="rule">Reference to the rule object.</param>
/// <param name="target">Target business object.</param>
/// <param name="inputPropertyValues">Input property values used by the rule.</param>
public RuleContext(Action <RuleContext> completeHandler, IBusinessRule rule, object target, Dictionary <Csla.Core.IPropertyInfo, object> inputPropertyValues)
: this(completeHandler)
{
Rule = rule;
if (rule.PrimaryProperty != null)
{
OriginPropertyName = rule.PrimaryProperty.Name;
}
Target = target;
InputPropertyValues = inputPropertyValues;
ExecuteContext = RuleContextModes.PropertyChanged;
}
/// <summary>
/// Gets a new RuleContext object for a chained rule.
/// </summary>
/// <param name="rule">Chained rule that will use
/// this new context.</param>
/// <remarks>
/// The properties from the existing RuleContext will be
/// used to create the new context, with the exception
/// of the Rule property which is set using the supplied
/// IBusinessRule value.
/// </remarks>
public RuleContext GetChainedContext(IBusinessRule rule)
{
var result = new RuleContext(_completeHandler);
result.Rule = rule;
if (!rule.IsAsync || rule.ProvideTargetWhenAsync)
{
result.Target = Target;
}
result.InputPropertyValues = InputPropertyValues;
result.Results = Results;
return(result);
}
// TODO: Add additional parameters to your rule to the constructor
public StringRequiredIfUS(IPropertyInfo primaryProperty, IPropertyInfo countryProperty)
: base(primaryProperty)
{
_countryProperty = countryProperty;
_innerRule = (IBusinessRule)new Csla.Rules.CommonRules.Required(primaryProperty);
InputProperties = new List<IPropertyInfo>();
// this rule needs the Country property
InputProperties.Add(countryProperty);
// add input properties required by inner rules
var inputProps = _innerRule.InputProperties.Where(inputProp => !InputProperties.Contains(inputProp));
if (inputProps.Count() > 0)
InputProperties.AddRange(inputProps);
}
/// <summary>
/// Initializes the test.
/// </summary>
/// <param name="rule">The rule.</param>
/// <param name="target">The target BO.</param>
public void InitializeTest(IBusinessRule rule, object target)
{
var services = new ServiceCollection();
services.AddCsla();
var provider = services.BuildServiceProvider();
var applicationContext = provider.GetRequiredService <ApplicationContext>();
Accessor = new ObjectAccessor(applicationContext);
_ruleContextCompleteWaitHandle = new EventWaitHandle(false, EventResetMode.AutoReset);
Rule = rule;
RuleContext = new RuleContext(applicationContext,
c => _ruleContextCompleteWaitHandle.Set(), rule, target, new Dictionary <IPropertyInfo, object>());
}
/// <summary>
/// Gets a new RuleContext object for a chained rule.
/// </summary>
/// <param name="rule">Chained rule that will use
/// this new context.</param>
/// <remarks>
/// The properties from the existing RuleContext will be
/// used to create the new context, with the exception
/// of the Rule property which is set using the supplied
/// IBusinessRule value.
/// </remarks>
public RuleContext GetChainedContext(IBusinessRule rule)
{
var result = new RuleContext(_completeHandler, _outputPropertyValues, _dirtyProperties, ExecuteContext);
result.Rule = rule;
result.OriginPropertyName = OriginPropertyName;
result.InputPropertyValues = InputPropertyValues;
result.Results = Results;
if (!rule.IsAsync || rule.ProvideTargetWhenAsync)
{
result.Target = Target;
}
return(result);
}
public ICollection <string> Validate <T>(T command) where T : ICommand
{
IBusinessRule rule = null;
try
{
rule = Container.Resolve <IBusinessRule <T> >();
}
catch (Exception)
{
return(new List <string>());
}
return(rule.Validate(command).ToList());
}
/// <summary>
/// Initializes a new instance of the <see cref="CheckFilteredCrossReferenceRule"/> class.
/// </summary>
/// <param name="primaryProperty">The primary property.</param>
/// <param name="innerRule">The inner rule.</param>
public CheckFilteredCrossReferenceRule(
IPropertyInfo primaryProperty,
IBusinessRule innerRule)
: base(primaryProperty)
{
RunMode = RunModes.DenyAsAffectedProperty;
InnerRule = innerRule;
RuleUri.AddQueryParameter("rule", Uri.EscapeUriString(InnerRule.RuleName));
InputProperties = InputProperties ?? new List<IPropertyInfo>();
InputProperties.Add(primaryProperty);
if (InnerRule.InputProperties != null)
InputProperties.AddRange(InnerRule.InputProperties);
InputProperties = InputProperties.Distinct().ToList();
}
/// <summary>
/// Initializes a new instance of the <see cref="CanWrite"/> class.
/// </summary>
/// <param name="primaryProperty">
/// The primary property.
/// </param>
/// <param name="innerRule">
/// The inner rule.
/// </param>
public CanWrite(IPropertyInfo primaryProperty, IBusinessRule innerRule)
: base(primaryProperty)
{
InputProperties = new List<IPropertyInfo> { primaryProperty };
InnerRule = innerRule;
RuleUri.AddQueryParameter("rule", System.Uri.EscapeUriString(InnerRule.RuleName));
// merge InnerRule input property list into this rule's list
if (InnerRule.InputProperties != null)
{
InputProperties.AddRange(InnerRule.InputProperties);
}
// remove any duplicates
InputProperties = new List<IPropertyInfo>(InputProperties.Distinct());
AffectedProperties.AddRange(innerRule.AffectedProperties);
}
// TODO: Add additional parameters to your rule to the constructor
public StringRequiredIfUS(IPropertyInfo primaryProperty, IPropertyInfo countryProperty)
: base(primaryProperty)
{
_countryProperty = countryProperty;
_innerRule = (IBusinessRule) new Csla.Rules.CommonRules.Required(primaryProperty);
InputProperties = new List <IPropertyInfo>();
// this rule needs the Country property
InputProperties.Add(countryProperty);
// add input properties required by inner rules
var inputProps = _innerRule.InputProperties.Where(inputProp => !InputProperties.Contains(inputProp));
if (inputProps.Count() > 0)
{
InputProperties.AddRange(inputProps);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="IsNew"/> class.
/// </summary>
/// <param name="primaryProperty">
/// The primary property.
/// </param>
/// <param name="innerRule">
/// The inner rule.
/// </param>
public IsNew(IPropertyInfo primaryProperty, IBusinessRule innerRule)
: base(primaryProperty)
{
InputProperties = new List <IPropertyInfo> {
primaryProperty
};
InnerRule = innerRule;
RuleUri.AddQueryParameter("rule", System.Uri.EscapeUriString(InnerRule.RuleName));
// merge InnerRule input property list into this rule's list
if (InnerRule.InputProperties != null)
{
InputProperties.AddRange(InnerRule.InputProperties);
}
// remove any duplicates
InputProperties = new List <IPropertyInfo>(InputProperties.Distinct());
AffectedProperties.AddRange(innerRule.AffectedProperties);
}
public TimeRangeRule(IPropertyInfo startTimeProperty, IPropertyInfo endTimeProperty,
IBusinessRule innerTopOfHourStartRule,
IBusinessRule innerTopOfHourEndRule ): base(startTimeProperty)
{
if (startTimeProperty == null)
throw new ArgumentException(ValidationMessages.StartTimePropertyArgumentInvalid);
if (endTimeProperty == null)
throw new ArgumentException(ValidationMessages.EndTimePropertyArgumentInvalid);
if (startTimeProperty.Type != typeof(DateTime))
throw new ArgumentException(ValidationMessages.PropertyIsNotOfTypeDatetime);
if (endTimeProperty.Type != typeof(DateTime))
throw new ArgumentException(ValidationMessages.PropertyIsNotOfTypeDatetime);
if (innerTopOfHourStartRule == null)
throw new ArgumentException(ValidationMessages.InnerRuleNotSupplied);
if (innerTopOfHourEndRule == null)
throw new ArgumentException(ValidationMessages.InnerRuleNotSupplied);
InnerTopOfHourStartRule = innerTopOfHourStartRule;
InnerTopOfHourEndRule = innerTopOfHourEndRule;
startPropertyInfo = startTimeProperty;
endPropertyInfo = endTimeProperty;
InputProperties.Add(startPropertyInfo);
InputProperties.Add(endPropertyInfo);
AffectedProperties.Add(endPropertyInfo);
RuleUri.AddQueryParameter("topHourStartRule", System.Uri.EscapeUriString(innerTopOfHourStartRule.RuleName));
RuleUri.AddQueryParameter("topHourEndRule", System.Uri.EscapeUriString(innerTopOfHourEndRule.RuleName));
}
/// <summary>
/// Initializes a new instance of <b>BusinessRuleCollection</b> class.
/// </summary>
/// <param name="firstRuleInCollection">First rule to add to collection.</param>
public BusinessRuleCollection(IBusinessRule firstRuleInCollection)
{
Add(firstRuleInCollection);
}
public BusinessRuleValidationException(IBusinessRule brokenRule) : base(brokenRule.Message)
{
BrokenRule = brokenRule;
this.Details = brokenRule.Message;
}
public void Add(int order, IBusinessRule businessRule)
{
_ruleContainer.Add(order, businessRule);
}
public TheCtor()
{
Rule = new ToUpper(RootFake.NameProperty);
}
/// <summary>
/// Constructs a new validation result class
/// </summary>
/// <param name="message">The error message to include</param>
/// <param name="rule">The business rule that instantiated this result</param>
/// <param name="propertyName">The name of the property affected</param>
public BusinessRuleValidationResult(string message, IBusinessRule rule, string propertyName)
: this(message)
{
BusinessRuleName = rule.BusinessRuleName;
PropertyName = propertyName;
}
/// <summary>
/// Determines whether this rule can run the specified context mode.
/// </summary>
/// <param name="rule">The rule.</param>
/// <param name="contextMode">The context mode.</param>
/// <returns>
/// <c>true</c> if this instance [can run rule] the specified context mode; otherwise, <c>false</c>.
/// </returns>
internal static bool CanRunRule(IBusinessRule rule, RuleContextModes contextMode)
{
// default then just return true
if (rule.RunMode == RunModes.Default) return true;
bool canRun = true;
if ((contextMode & RuleContextModes.AsAffectedPoperty) > 0)
canRun = canRun & (rule.RunMode & RunModes.DenyAsAffectedProperty) == 0;
if ((rule.RunMode & RunModes.DenyOnServerSidePortal) > 0)
canRun = canRun & ApplicationContext.LogicalExecutionLocation != ApplicationContext.LogicalExecutionLocations.Server;
if ((contextMode & RuleContextModes.CheckRules) > 0)
canRun = canRun & (rule.RunMode & RunModes.DenyCheckRules) == 0;
return canRun;
}
/// <summary>
/// Associates a business rule with the business object.
/// </summary>
/// <param name="rule">Rule object.</param>
/// <param name="ruleSet">Rule set name.</param>
public void AddRule(IBusinessRule rule, string ruleSet)
{
var typeRules = BusinessRuleManager.GetRulesForType(_target.GetType(), ruleSet);
typeRules.Rules.Add(rule);
}
/// <summary>
/// Associates a business rule with the business object.
/// </summary>
/// <param name="rule">Rule object.</param>
public void AddRule(IBusinessRule rule)
{
TypeRules.Rules.Add(rule);
}
/// <summary>
/// Adds a <b>BusinessRule</b> to the end of the <b>BusinessRuleCollection</b>.
/// </summary>
/// <param name="rule">The rule to be added to the end of the collection. <b>null</b> is not allowed.</param>
/// <returns>The rule which was added to the collection.</returns>
public IBusinessRule Add(IBusinessRule rule)
{
if (rule == null)
throw new ArgumentException("Null is not allowed.");
this.list.Add(rule);
return rule;
}
public void InitTests()
{
Rule = new LookupCustomer(RootFake.CustomerIdProperty, RootFake.NameProperty);
}
private static string GetTypeName(IBusinessRule rule)
{
var type = rule.GetType();
return GetTypeName(type);
}
/// <summary>
/// Creates an instance of the object.
/// </summary>
/// <param name="rule">Rule object.</param>
/// <param name="property">Property to which rule applies.</param>
public RuleUri(IBusinessRule rule, Csla.Core.IPropertyInfo property)
: this(GetTypeName(rule), ((property == null) ? "(object)" : property.Name))
//: this(rule.GetType().FullName, ((property == null) ? "null" : property.Name))
{ }
