public void Write(IStyleSystem styleSystem, XContainer container, ICondition condition, IConditionWriter childWriter)
{
IConditionWriter w;
if (writers.TryGetValue(condition.GetType(), out w))
{
w.Write(styleSystem, container, condition, childWriter);
}
else
{
throw new StyleWriterException("There is no writer for condition " + condition.GetType().Name);
}
}
/// <summary>
/// Add a condition to the collection. The method checks if the condition is applicable, through the IsApplicable method. If not, it throws exception.
/// The method checks if the condition is already present in the collection. If yes, it throws an exeception.
/// The condition is registered among the other conditions having the same Type.
/// </summary>
/// <param name="condition"></param>
public void AddCondition(ICondition condition)
{
string str;
List <ICondition> list;
if (condition == null)
{
throw new ArgumentNullException("condition");
}
if (!condition.IsApplicable(out str))
{
throw new Exception(str);
}
System.Type key = condition.GetType();
if (!this._conditions.TryGetValue(key, out list))
{
list = new List <ICondition> {
condition
};
this._conditions.Add(key, list);
}
else
{
if (list.Contains(condition))
{
throw new Exception("The conditions' set already contains this condition");
}
list.Add(condition);
}
}
public CommandWindow(ICondition condition)
{
InitializeComponent();
Condition = condition;
Title = new LocalizationConverter().Convert(Condition, null, null, null) as string;
Initialize(condition, condition.GetType());
}
private string CompileCondition(ICondition condition)
{
switch (condition)
{
case EqualCondition equalCondition:
return(this.GetEqualCamlCondition(equalCondition));
default:
throw new ArgumentException($"Not supported condition type: {condition.GetType()}", nameof(condition));
}
}
private static bool IsAnyConditionNull(ICondition condition, string conditionName = "")
{
if (condition == null)
{
BH.Engine.Reflection.Compute.RecordError($"The condition is null. Please specify a valid condition.");
return(true);
}
// Collect all sub-properties of type Condition from the condition and check if any is null
bool isAnyNull = false;
var subConditions = condition.GetType().GetProperties().Where(p => p.PropertyType is ICondition);
foreach (var subCond in subConditions)
{
if (subCond.GetValue(condition) == null)
{
BH.Engine.Reflection.Compute.RecordError($"The condition `{condition.GetType().Name}.{subCond.Name}` is null. Please specify a valid condition.");
isAnyNull = true;
}
}
return(isAnyNull);
}
//--------------------------------------------------
// Link with exit code and condition
//--------------------------------------------------
/// <summary>
/// 用退出码和条件和路径连接两个状态，当起点状态按指定退出码退出并满足条件时按路径迁移到终点状态。
/// </summary>
/// <param name="from">起点状态。</param>
/// <param name="to">终点状态。</param>
/// <param name="exitCode">退出码。</param>
/// <param name="condition">条件类的实例。</param>
/// <param name="path">起点和终点状态之间的过渡路径。</param>
protected void Link(FsmState from, FsmState to, int exitCode, ICondition condition, bool inverse,
params FsmState[] path)
{
Dictionary <int, Dictionary <ICondition, ToAndList> > connections;
Dictionary <ICondition, ToAndList> subConnections;
condition = GetCondition(condition, inverse);
if (!graphExitConditionConnections.TryGetValue(from, out connections))
{
connections = new Dictionary <int, Dictionary <ICondition, ToAndList> >();
subConnections = new Dictionary <ICondition, ToAndList>();
subConnections.Add(condition, new ToAndList(to, path));
connections.Add(exitCode, subConnections);
graphExitConditionConnections.Add(from, connections);
return;
}
if (!connections.TryGetValue(exitCode, out subConnections))
{
subConnections = new Dictionary <ICondition, ToAndList>();
subConnections.Add(condition, new ToAndList(to, path));
connections.Add(exitCode, subConnections);
return;
}
ToAndList toAndList;
if (!subConnections.TryGetValue(condition, out toAndList))
{
toAndList = new ToAndList(to, path);
subConnections.Add(condition, toAndList);
return;
}
throw new Exception(string.Format(
"Try to override exist exit+condition connection:" +
"\n{0} --> {2} : {1}\n{0} --> {3} : exit({4}) + {1}\n",
from.GetType().Name,
condition.GetType().Name,
toAndList.To.GetType().Name,
to.GetType().Name,
exitCode));
}
public static IExpression Where(this IStatement statement, ICondition criteria)
{
if (criteria == null)
{
return(null);
}
if (criteria is Condition c)
{
return(GetConditionExpression(statement, c));
}
if (criteria is ConditionCollection cc)
{
return(GetConditionExpression(statement, cc));
}
throw new NotSupportedException($"The '{criteria.GetType().FullName}' type is an unsupported condition type.");
}
public virtual EntityExpression <TEntity> Where(ICondition condition, string oprand = "and")
{
if (condition != null)
{
switch (condition.GetType().Name)
{
case "ExpressionCondition`1":
HandleCondition(oprand, (ExpressionCondition <TEntity>)condition);
break;
//case "CombinCondition`1":
// HandleCondition(oprand, (CombinCondition<TEntity>)condition);
// break;
default:
break;
}
}
return(this);
}
public static IExpression Where(this IStatement statment, ICondition criteria)
{
if (criteria == null)
{
return(null);
}
if (criteria is Condition c)
{
return(ConditionExtension.ToExpression(c, field => From(statment, field, out var property).CreateField(property), parameter => statment.Parameters.Add(parameter)));
}
if (criteria is ConditionCollection cc)
{
return(ConditionExtension.ToExpression(cc, field => From(statment, field, out var property).CreateField(property), parameter => statment.Parameters.Add(parameter)));
}
throw new NotSupportedException($"The '{criteria.GetType().FullName}' type is an unsupported condition type.");
}
public IEnumerator Condition()
{
// Given a training which has a step with a condition
ICourse training1 = new LinearTrainingBuilder("Training")
.AddChapter(new LinearChapterBuilder("Chapter")
.AddStep(new BasicStepBuilder("Step")
.AddCondition(new TimeoutCondition(2.5f))))
.Build();
// When we serialize and deserialize it
ICourse training2 = JsonTrainingSerializer.Deserialize((JsonTrainingSerializer.Serialize(training1)));
// Then that condition's name should not change.
ICondition condition1 = training1.Data.FirstChapter.Data.FirstStep.Data.Transitions.Data.Transitions.First().Data.Conditions.First();
ICondition condition2 = training2.Data.FirstChapter.Data.FirstStep.Data.Transitions.Data.Transitions.First().Data.Conditions.First();
Assert.AreEqual(condition1.GetType(), condition2.GetType());
return(null);
}
private void ValidateCondition(ValidationContext context, ICondition condition)
{
context.AssertNotNull(condition, "Condition");
if (condition is IBinaryCondition <string> strCondition)
{
ValidateBinaryCondition(context, strCondition);
}
else if (condition is IBinaryCondition binCondition)
{
ValidateBinaryCondition(context, binCondition);
}
else if (condition is INaryCondition iNaryCondition)
{
ValidateNAryCondition(context, iNaryCondition);
}
else if (condition is NotCondition notCondition)
{
ValidateCondition(context, notCondition.Condition);
}
else if (condition != null)
{
throw new ValidationException("Unsupported condition type: " + condition.GetType());
}
}
public static MethodInfo CreateMethod(this ICondition condition)
{
return(GenerateDynamicMethod(condition.GetType(), condition.Name, "IsValid"));
}
public static Type GetMethodType(this ICondition condition)
{
return(GenerateGenericDelegate(condition.GetType()));
}
private ConditionControlBase GetControlForCondition(ICondition c, ConditionControlBase parent)
{
ConditionControlBase control = null;
if (c == null)
{
ConditionPlaceholderControl cpc = new ConditionPlaceholderControl();
cpc.ParentConditionControl = parent;
cpc.InsertCondition += new EventHandler<InsertConditionEventArgs>(InsertCondition);
Controls.Add(cpc);
control = cpc;
}
else if (c.GetType() == typeof(ResponseStatusCodeEqualToCondition))
{
ResponseStatusEqualToControl ctl = new ResponseStatusEqualToControl();
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
}
else if (c.GetType() == typeof(ResponseStatusCodeEqualToNotCondition))
{
ResponseStatusNotEqualToControl ctl = new ResponseStatusNotEqualToControl();
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
}
else if (c.GetType() == typeof(ResponseBodyContainsCondition))
{
ResponseBodyContainsControl ctl = new ResponseBodyContainsControl();
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
}
else if (c.GetType() == typeof(ResponseBodyContainsNotCondition))
{
ResponseBodyContainsNotControl ctl = new ResponseBodyContainsNotControl();
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
}
else if (c.GetType() == typeof(ResponseBodyRegexMatchCondition))
{
ResponseBodyContainsRegexControl ctl = new ResponseBodyContainsRegexControl();
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
}
else if (c.GetType() == typeof(ResponseBodyRegexMatchNotCondition))
{
ResponseBodyContainsRegexNotControl ctl = new ResponseBodyContainsRegexNotControl();
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
}
else if (c.GetType() == typeof(AndCondition) || c.GetType() == typeof(OrCondition))
{
BinaryCondition bc = c as BinaryCondition;
BinaryConditionControl ctl = (c.GetType() == typeof(AndCondition) ? (BinaryConditionControl)new AndControl() : (BinaryConditionControl)new OrControl());
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
ctl.SubconditionControls.Add(GetControlForCondition(bc.Condition2 as ICondition, ctl));
ctl.SubconditionControls.Add(GetControlForCondition(bc.Condition1 as ICondition, ctl));
}
control.ParentConditionControl = parent;
//if (parent != null)
// parent.SubconditionControls.Add(control);
control.DeleteCondition += new EventHandler<DeleteConditionEventArgs>(DeleteCondition);
return control;
}
private ConditionControlBase GetControlForCondition(ICondition c, ConditionControlBase parent)
{
ConditionControlBase control = null;
if (c == null)
{
ConditionPlaceholderControl cpc = new ConditionPlaceholderControl();
cpc.ParentConditionControl = parent;
cpc.InsertCondition += new EventHandler <InsertConditionEventArgs>(InsertCondition);
Controls.Add(cpc);
control = cpc;
}
else if (c.GetType() == typeof(ResponseStatusCodeEqualToCondition))
{
ResponseStatusEqualToControl ctl = new ResponseStatusEqualToControl();
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
}
else if (c.GetType() == typeof(ResponseStatusCodeEqualToNotCondition))
{
ResponseStatusNotEqualToControl ctl = new ResponseStatusNotEqualToControl();
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
}
else if (c.GetType() == typeof(ResponseBodyContainsCondition))
{
ResponseBodyContainsControl ctl = new ResponseBodyContainsControl();
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
}
else if (c.GetType() == typeof(ResponseBodyContainsNotCondition))
{
ResponseBodyContainsNotControl ctl = new ResponseBodyContainsNotControl();
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
}
else if (c.GetType() == typeof(ResponseBodyRegexMatchCondition))
{
ResponseBodyContainsRegexControl ctl = new ResponseBodyContainsRegexControl();
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
}
else if (c.GetType() == typeof(ResponseBodyRegexMatchNotCondition))
{
ResponseBodyContainsRegexNotControl ctl = new ResponseBodyContainsRegexNotControl();
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
}
else if (c.GetType() == typeof(AndCondition) || c.GetType() == typeof(OrCondition))
{
BinaryCondition bc = c as BinaryCondition;
BinaryConditionControl ctl = (c.GetType() == typeof(AndCondition) ? (BinaryConditionControl) new AndControl() : (BinaryConditionControl) new OrControl());
ctl.Condition = c;
Controls.Add(ctl);
control = ctl;
ctl.SubconditionControls.Add(GetControlForCondition(bc.Condition2 as ICondition, ctl));
ctl.SubconditionControls.Add(GetControlForCondition(bc.Condition1 as ICondition, ctl));
}
control.ParentConditionControl = parent;
//if (parent != null)
// parent.SubconditionControls.Add(control);
control.DeleteCondition += new EventHandler <DeleteConditionEventArgs>(DeleteCondition);
return(control);
}
public static IExpression Where(this IStatement statement, ICondition criteria)
{
if(criteria == null)
return null;
if(criteria is Condition c)
return ConditionExtension.ToExpression(c,
field => GetField(statement, field),
parameter => statement.Parameters.Add(parameter));
if(criteria is ConditionCollection cc)
return ConditionExtension.ToExpression(cc,
field => GetField(statement, field),
parameter => statement.Parameters.Add(parameter));
throw new NotSupportedException($"The '{criteria.GetType().FullName}' type is an unsupported condition type.");
FieldIdentifier GetField(IStatement host, Condition condition)
{
var source = From(statement, condition.Name, (src, complex) => CreateSubquery(host, src, complex, condition.Value as ICondition), out var property);
if(property.IsSimplex)
return source.CreateField(property);
if(condition.Operator == ConditionOperator.Exists || condition.Operator == ConditionOperator.NotExists)
{
condition.Value = source;
return null;
}
throw new DataException($"The specified '{condition.Name}' condition is associated with a one-to-many composite(navigation) property and does not support the {condition.Operator} operation.");
}
ISource CreateSubquery(IStatement host, ISource source, IDataEntityComplexProperty complex, ICondition condition)
{
var subquery = host.Subquery(complex.Foreign);
var where = ConditionExpression.And();
foreach(var link in complex.Links)
{
subquery.Select.Members.Add(subquery.Table.CreateField(link.Foreign));
where.Add(Expression.Equal(
subquery.Table.CreateField(link.Foreign),
source.CreateField(link.Principal)
));
}
if(complex.HasConstraints())
{
foreach(var constraint in complex.Constraints)
{
where.Add(Expression.Equal(
subquery.Table.CreateField(constraint.Name),
complex.GetConstraintValue(constraint)
));
}
}
if(condition != null)
where.Add(Where(subquery, condition));
subquery.Where = where;
return subquery;
}
}
/***************************************************/
//Fallback
private static ConditionResult VerifyCondition(List <object> objects, ICondition condition)
{
BH.Engine.Reflection.Compute.RecordError($"Could not apply {condition.GetType().Name}. No method found.");
return(null);
}
public static ICondition ExtendedConvertToCondition(this ConditionModel model, IEntityMetadata metaData, IEntityRegistry registry, IServiceProvider services)
{
if (((IEnumerable <object>)metaData.Type.GetCustomAttributes(typeof(ObsoleteAttribute), false)).Any <object>())
{
return((ICondition)null);
}
ICondition instance1 = ActivatorUtilities.CreateInstance(services, metaData.Type, Array.Empty <object>()) as ICondition;
if (instance1 == null)
{
return((ICondition)null);
}
PropertyInfo[] properties = instance1.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
if (((IEnumerable <PropertyInfo>)properties).Any <PropertyInfo>((Func <PropertyInfo, bool>)(p => ModelExtensions.IsBinaryOperator(p.PropertyType))))
{
PropertyInfo propertyInfo = ((IEnumerable <PropertyInfo>)properties).FirstOrDefault <PropertyInfo>((Func <PropertyInfo, bool>)(p => ModelExtensions.IsBinaryOperator(p.PropertyType)));
PropertyModel operatorModelProperty = model.Properties.FirstOrDefault <PropertyModel>((Func <PropertyModel, bool>)(x => x.IsOperator));
if (operatorModelProperty != null)
{
IEntityMetadata entityMetadata = registry.GetOperators().FirstOrDefault <IEntityMetadata>((Func <IEntityMetadata, bool>)(m => m.Type.FullName.Equals(operatorModelProperty.Value, StringComparison.OrdinalIgnoreCase)));
object instance2 = ActivatorUtilities.CreateInstance(services, entityMetadata?.Type, Array.Empty <object>());
if ((object)propertyInfo != null)
{
propertyInfo.SetValue((object)instance1, instance2);
}
}
}
foreach (PropertyModel property1 in (IEnumerable <PropertyModel>)model.Properties)
{
if (!property1.IsOperator)
{
PropertyInfo property2 = instance1.GetType().GetProperty(property1.Name, BindingFlags.Instance | BindingFlags.Public);
Type type = (!property2.PropertyType.IsGenericType ? 0 : (typeof(IRuleValue <>).IsAssignableFrom(property2.PropertyType.GetGenericTypeDefinition()) ? 1 : 0)) != 0 ? ((IEnumerable <Type>)property2.PropertyType.GetGenericArguments()).FirstOrDefault <Type>() : property2.PropertyType;
if (!(type == (Type)null))
{
string fullName = type.FullName;
if (!(fullName == "System.DateTime"))
{
if (!(fullName == "System.DateTimeOffSet"))
{
if (!(fullName == "System.Int32"))
{
if (!(fullName == "System.Boolean")) //our extended boolean condition
{
if (fullName == "System.Decimal")
{
Decimal result;
Decimal.TryParse(property1.Value, out result);
LiteralRuleValue <Decimal> literalRuleValue = new LiteralRuleValue <Decimal>()
{
Value = result
};
property2.SetValue((object)instance1, (object)literalRuleValue, (object[])null);
}
else
{
LiteralRuleValue <string> literalRuleValue = new LiteralRuleValue <string>()
{
Value = property1.Value
};
property2.SetValue((object)instance1, (object)literalRuleValue, (object[])null);
}
}
else
{
bool result;
bool.TryParse(property1.Value, out result);
LiteralRuleValue <bool> literalRuleValue = new LiteralRuleValue <bool>()
{
Value = result
};
property2.SetValue((object)instance1, (object)literalRuleValue, (object[])null);
}
}
else
{
int result;
int.TryParse(property1.Value, out result);
LiteralRuleValue <int> literalRuleValue = new LiteralRuleValue <int>()
{
Value = result
};
property2.SetValue((object)instance1, (object)literalRuleValue, (object[])null);
}
}
else
{
DateTimeOffset result;
DateTimeOffset.TryParse(property1.Value, out result);
LiteralRuleValue <DateTimeOffset> literalRuleValue = new LiteralRuleValue <DateTimeOffset>()
{
Value = result
};
property2.SetValue((object)instance1, (object)literalRuleValue, (object[])null);
}
}
else
{
DateTime result;
DateTime.TryParse(property1.Value, out result);
LiteralRuleValue <DateTime> literalRuleValue = new LiteralRuleValue <DateTime>()
{
Value = result
};
property2.SetValue((object)instance1, (object)literalRuleValue, (object[])null);
}
}
}
}
return(instance1);
}
