public IConditionGroup BeginGroup(LogicalOperator concatOperator = LogicalOperator.And)
{
var group = new ConditionGroup(concatOperator);
Add(group);
return(group);
}
private void OnAddGroup(ConditionGroup group)
{
var newGroup = new ConditionGroup();
group.Items.Add(newGroup);
newGroup.Parent = group;
}
public virtual IEnumerable <int> GetConditionIdsInGroup(ConditionGroup group)
{
switch (group)
{
case ConditionGroup.None:
return(GetConditionIdsForConditionGroupNone());
case ConditionGroup.Attitude:
return(GetConditionIdsForConditionGroupAttitude());
case ConditionGroup.DeathAndDying:
return(GetConditionIdsForConditionGroupDeathAndDying());
case ConditionGroup.DegreesOfDetection:
return(GetConditionIdsForConditionGroupDegreesOfDetection());
case ConditionGroup.LoweredAbilities:
return(GetConditionIdsForConditionGroupLoweredAbilities());
case ConditionGroup.Senses:
return(GetConditionIdsForConditionGroupSenses());
}
var msg = string.Format("Condition groul '{0}' not supported.");
throw new System.NotSupportedException(msg);
}
public void TestClone()
{
IConditionGroup group = new ConditionGroup(Guid.NewGuid(), new TranslateableLanguageItem(Guid.NewGuid()), ConditionLogic.AND, true);
ICondition condition1 = new Condition(Guid.NewGuid(), "className1", new TranslateableLanguageItem(Guid.NewGuid()), OperatorType.GreaterThan);
ICondition condition2 = new Condition(Guid.NewGuid(), "className2", new TranslateableLanguageItem(Guid.NewGuid()), OperatorType.LessThan);
group.Conditions.Add(condition1);
group.Conditions.Add(condition2);
IConditionGroup copyGroup = (group as PolicyObject).Clone() as IConditionGroup;
Assert.IsNotNull(copyGroup);
Assert.AreNotEqual(group.Identifier, copyGroup.Identifier);
Assert.AreEqual(group.Logic, copyGroup.Logic);
Assert.AreNotEqual(group.Name.Identifier, copyGroup.Name.Identifier);
Assert.AreEqual(group.Name.Value, copyGroup.Name.Value);
Assert.AreEqual(group.ReadOnly, copyGroup.ReadOnly);
Assert.IsNotNull(copyGroup.Conditions);
Assert.AreEqual(group.Conditions.Count, copyGroup.Conditions.Count);
ICondition copyCondition1 = copyGroup.Conditions[0] as ICondition;
Assert.IsNotNull(copyCondition1);
Assert.AreNotEqual(condition1.Identifier, copyCondition1.Identifier);
Assert.AreNotEqual(condition1.Name.Identifier, copyCondition1.Name.Identifier);
Assert.AreEqual(condition1.Name.Value, copyCondition1.Name.Value);
Assert.AreEqual(condition1.Operator, copyCondition1.Operator);
Assert.AreEqual(condition1.ReadOnly, copyCondition1.ReadOnly);
ICondition copyCondition2 = copyGroup.Conditions[1] as ICondition;
Assert.IsNotNull(copyCondition2);
Assert.AreNotEqual(condition2.Identifier, copyCondition2.Identifier);
Assert.AreNotEqual(condition2.Name.Identifier, copyCondition2.Name.Identifier);
Assert.AreEqual(condition2.Name.Value, copyCondition2.Name.Value);
Assert.AreEqual(condition2.Operator, copyCondition2.Operator);
Assert.AreEqual(condition2.ReadOnly, copyCondition2.ReadOnly);
}
private void UpdateEditorToCondition(ConditionGroup r)
{
BuildTreeFromCondition(r);
TreeSort();
trvNodes.SelectedNode = trvNodes.Nodes[0];
trvNodes.Nodes[0].Expand();
}
private void btnAddGroup_Click(object sender, EventArgs e)
{
ConditionGroup re = new ConditionGroup();
TreeNode tn = new TreeNode();
AttachConditionComponentToNode(tn, re);
TreeNode tx = trvNodes.SelectedNode;
ConditionComponent rx = (ConditionComponent)tx.Tag;
if (rx is ConditionSingle)
{
tx = GetReverseLookup(rx.Parent);
re.Parent = rx.Parent;
}
if (rx is ConditionGroup)
{
tx = GetReverseLookup(rx);
re.Parent = (ConditionGroup)rx;
}
re.Parent.Children.Add(re);
tx.Nodes.Add(tn);
RecolorStartingFromNode(tx, tx.Checked);
TreeSort();
trvNodes.SelectedNode = tn;
if (tx.IsExpanded == false)
{
tx.Expand();
}
}
private void cbxGroupingType_SelectedIndexChanged(object sender, EventArgs e)
{
TreeNode tn = trvNodes.SelectedNode;
ConditionGroup re = (ConditionGroup)tn.Tag;
switch (cbxGroupingType.SelectedIndex)
{
case 0:
re.Grouping = ConditionGroup.CndGroupingEnum.And;
break;
case 1:
re.Grouping = ConditionGroup.CndGroupingEnum.Or;
break;
case 2:
re.Grouping = ConditionGroup.CndGroupingEnum.Xor;
break;
case 3:
re.Grouping = ConditionGroup.CndGroupingEnum.Not;
break;
}
UpdateNodeIcon(tn);
TreeSort();
}
/// <summary>
/// Carga de un documento XML de díalogos para un actor determinado.
/// </summary>
/// <param name="actor">Nombre interno o referencia del actor</param>
/// <param name="doc">Documento XML que contiene los diálogos para el actor</param>
private void LoadActorDocumentXML(string actor, XmlDocument doc)
{
ActorBrain actorBrain = dialogsManager.GetActorBrain(actor);
XmlNodeList rootChildren = doc.DocumentElement.ChildNodes;
foreach (XmlNode childNode in rootChildren)
{
switch (childNode.Name)
{
case "definitions":
ProcessDefinitions(actorBrain, childNode);
break;
case "conditions":
case "conditionsAnd":
case "conditionsOr":
ConditionGroup conditions = ProcessConditionGroup(actorBrain, null, childNode);
actorBrain.GetDialogs().AddConditions(conditions);
break;
case "dialog":
Dialog dialog = ProcessDialog(actorBrain, null, childNode);
dialogsManager.AddActorDialog(actor, dialog);
break;
}
}
}
internal List <KeyValuePair <string, object> > GetParameters(int num)
{
var parameters = new List <KeyValuePair <string, object> >();
if (RightValue != null)
{
ParameterName = $"Param{num}";
parameters.Add(new KeyValuePair <string, object>(ParameterName, RightValue));
}
foreach (var p in AdditionalParameterValues)
{
var paramName = $"Param{num + parameters.Count}";
var kvp = new KeyValuePair <string, object>(paramName, p);
parameters.Add(kvp);
AdditionalParameters.Add(kvp);
}
if (ConditionGroup != null)
{
parameters.AddRange(ConditionGroup.GetParameters(num + parameters.Count));
}
if (Sibling != null)
{
parameters.AddRange(Sibling.GetParameters(num + parameters.Count));
}
return(parameters);
}
private ConditionGroup FindConditionGroup(ConditionGroup condition, string groupconditionId)
{
if (String.Equals(condition.ConditionId, groupconditionId, StringComparison.OrdinalIgnoreCase))
{
return(condition);
}
if (!condition.Conditions.Any())
{
return(null);
}
ConditionGroup result;
foreach (var nestedCondition in condition.Conditions.OfType <ConditionGroup>())
{
// Search in inner conditions
result = FindConditionGroup(nestedCondition, groupconditionId);
if (result != null)
{
return(result);
}
}
return(null);
}
private static string WriteConditionGroup(ConditionGroup conditionGroup, SqlParameterCollection parameters)
{
StringBuilder sqlBuilder = new StringBuilder("(");
bool first = true;
foreach (ICondition condition in conditionGroup.Conditions)
{
if (!first)
{
switch (conditionGroup.ConditionGroupType)
{
case ConditionGroup.ConditionGroupTypes.And:
sqlBuilder.Append(" AND ");
break;
case ConditionGroup.ConditionGroupTypes.Or:
sqlBuilder.Append(" OR ");
break;
default:
throw new InvalidCastException("Could not determine Condition Group Type while writing");
}
}
sqlBuilder.Append(WriteCondition(condition, parameters));
first = false;
}
sqlBuilder.Append(")");
return(sqlBuilder.ToString());
}
public bool ConditionMatches(Regex rex, ConditionGroup cg)
{
if (cg == null)
{
return(false);
}
foreach (ConditionComponent cc in cg.Children)
{
if (cc is ConditionSingle)
{
ConditionSingle cs = (ConditionSingle)cc;
if (RegexMatches(rex, cs.ExpressionL) == true)
{
return(true);
}
if (RegexMatches(rex, cs.ExpressionR) == true)
{
return(true);
}
}
if (cc is ConditionGroup)
{
if (ConditionMatches(rex, (ConditionGroup)cc) == true)
{
return(true);
}
}
}
return(false);
}
public void ConditionGroup_With_None_JoinOperator_Evaluates_Conditions_Like_NAN()
{
var conditionGroup_True_True = new ConditionGroup
{
JoinOperator = JoinOperator.None,
Conditions = new[]
{
ConditionThatIsAlwaysTrue,
ConditionThatIsAlwaysTrue
}
};
var conditionGroup_True_False = new ConditionGroup
{
JoinOperator = JoinOperator.None,
Conditions = new[]
{
ConditionThatIsAlwaysTrue,
ConditionThatIsAlwaysFalse
}
};
var conditionGroup_False_False = new ConditionGroup
{
JoinOperator = JoinOperator.None,
Conditions = new[]
{
ConditionThatIsAlwaysFalse,
ConditionThatIsAlwaysFalse
}
};
Assert.False(conditionGroup_True_True.AreConditionsMet(AnalyzerResult));
Assert.False(conditionGroup_True_False.AreConditionsMet(AnalyzerResult));
Assert.True(conditionGroup_False_False.AreConditionsMet(AnalyzerResult));
}
internal override PropertyExpression Export([NotNull] ConditionGroup parent, [NotNull] IPropertyCollection propertyCollection)
{
var property = propertyCollection.GetProperty(PropertyName);
var propertyExpression = new PropertyExpression
{
Parent = parent,
Property = property
};
var dataTypeExpression = propertyExpression.DataTypeExpression;
dataTypeExpression.SelectedCondition = Condition.Matches;
var reflectionService = this.GetDependencyResolver().Resolve <IReflectionService>();
var properties = reflectionService.GetInstanceProperties(property.Type);
var group = new ConditionGroup()
{
Type = ConditionGroupType.And
};
Conditions.Select(o => o.Export(group, properties)).Sink(group.Items.Add);
((ComplexTypeExpression)dataTypeExpression).Value = new FilterScheme(property.Type, "Default", group);
return(propertyExpression);
}
public T GetRecord(params object[] keys)
{
ConditionGroup condition = getKeysConditionGroup(keys);
var records = GetTable(condition);
return(records.FirstOrDefault());
}
private void OnAddExpression(ConditionGroup group)
{
var propertyExpression = new PropertyExpression();
propertyExpression.Property = InstanceProperties.FirstOrDefault();
group.Items.Add(propertyExpression);
propertyExpression.Parent = group;
}
public void Setup()
{
Converter = GetConverter();
Conditions = new ConditionGroup();
ConditionGroups = new List <IConditionGroup> {
Conditions
};
}
public SelectQuery(ConditionGroupType RootConditionsType)
{
tables = new Dictionary<string, IQueryTable>();
fieldsContainer = new QueryFieldsContainer();
selectFields = new List<string>();
sortingFields = new Dictionary<string, SortDirection>();
RootCondition = new ConditionGroup(RootConditionsType, fieldsContainer);
}
private void SetGroup(ConditionGroup group, string property, string value)
{
switch (property)
{
case "ConditionType":
group.ConditionType = (ConditionType)int.Parse(value);;
break;
}
}
/// <summary>
/// Factory method that dynamically instantiates a configured feature using condition group metadata
/// </summary>
/// <param name="featureScope">The scope in which to look for this feature</param>
/// <param name="name">Name of the feature</param>
/// <param name="conditionGroupMetadata">Metadata defining the feature condition group</param>
/// <returns>Instance of the defined feature</returns>
public static ConfiguredFeature GetInstance(FeatureScope featureScope, string name, ConditionGroupMetadata conditionGroupMetadata)
{
var conditionGroup = new ConditionGroup
{
JoinOperator = conditionGroupMetadata.JoinOperator,
Conditions = ConditionFactory.GetConditions(conditionGroupMetadata.Conditions)
};
return(new ConfiguredFeature(featureScope, name, conditionGroup));
}
public VMconditionGroup(ConditionGroup root, VMcondition parent) : base(root, parent)
{
this.Wrap();
this.CommandAddSet = new DelegateCommand(this.Add);
this.CommandRemoveSet = new DelegateCommand(this.Remove, this.CanRemove);
this.CommandRemove = new DelegateCommand(() => this.Parent.Root.Groups.Remove(this.Root));
this.Root.Conditions.CollectionChanged += new NotifyCollectionChangedEventHandler(this.CollectionChanged);
this.Root.Connectors.CollectionChanged += new NotifyCollectionChangedEventHandler(this.CollectionChanged);
}
public void InsertCondition(ConditionGroup c)
{
ConditionGroup p = myParent;
c.AddCondition(this);
if (p != null)
{
p.mConditions.Remove(this);
p.AddCondition(c);
}
}
public void Add_1ConditionGroup_CheckValue()
{
var expected = new FieldCondition(new Field("F1"), RelationalOperators.Equal, 123);
var groupToAdd = new ConditionGroup(new [] { expected });
_conditionGroup.Add(groupToAdd);
var actual = (IFieldCondition)((IConditionGroup)_conditionGroup.Conditions[0]).Conditions[0];
Assert.AreEqual(expected.Value, actual.Value);
}
public T[] Filter <T>(IEnumerable <T> data, ConditionGroup group)
{
var parameterExpression = CreateParameter(typeof(T), PARAMETER_NAME);
var expression = BuildExpression(parameterExpression, group);
var lambda = Expression.Lambda <Func <T, bool> >(expression, parameterExpression);
var where = lambda.Compile();
return(data.Where(where).ToArray());
}
public static ConditionGroup GenerateConditionGroup()
{
var conditionGroup = new ConditionGroup
{
Type = ConditionGroupType.And
};
conditionGroup.Items.Add(GenerateStringExpression());
conditionGroup.Items.Add(GenerateBoolExpression());
conditionGroup.Items.Add(GenerateIntExpression());
return(conditionGroup);
}
public FilterScheme Export(Type entityType)
{
var reflectionService = this.GetDependencyResolver().Resolve <IReflectionService>();
var properties = reflectionService.GetInstanceProperties(entityType);
var group = new ConditionGroup()
{
Type = ConditionGroupType.And
};
Conditions.Select(o => o.Export(group, properties)).Sink(group.Items.Add);
var scheme = new FilterScheme(entityType, "Default", group);
return(scheme);
}
public IEnumerable <T> GetTable(ConditionGroup conditionGroup, params SqlParameter[] conditionParams)
{
using (SqlCommand command = new SqlCommand())
{
command.CommandText = SqlCommandBuilder.GetDefaultSelectCommand(TableName)
.AddConditionGroup(conditionGroup)
.Build();
command.Parameters.AddRange(conditionParams);
command.Connection = Connection;
return(mapReader(command.ExecuteReader()));
}
}
public override void NodeGUI()
{
while (outputKnobs.Count > groupCount)
{
groups.Add(new ConditionGroup
{
output = outputKnobs[groupCount],
input = inputKnobs[groupCount + 1]
});
groupCount++;
}
for (int i = 0; i < groups.Count; i++)
{
RTEditorGUI.Seperator();
GUILayout.BeginHorizontal();
if (GUILayout.Button("x", GUILayout.ExpandWidth(false)))
{
// Remove current label
DeleteConnectionPort(groups[i].input);
DeleteConnectionPort(groups[i].output);
groups.RemoveAt(i);
i--;
GUILayout.EndHorizontal();
continue;
}
GUILayout.Label("Group " + i);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
groups[i].input.DisplayLayout();
groups[i].output.DisplayLayout();
GUILayout.EndHorizontal();
}
GUILayout.BeginHorizontal();
if (GUILayout.Button("Add", GUILayout.ExpandWidth(false), GUILayout.MinWidth(100f)))
{
ConditionGroup group = new ConditionGroup
{
input = CreateConnectionKnob(inputAttribute),
output = CreateConnectionKnob(outputAttribute)
};
groups.Add(group);
groupCount++;
}
GUILayout.EndHorizontal();
}
internal void CountItems(ConditionGroup rge, ref int numgroups, ref int numrules)
{
numgroups++;
foreach (ConditionComponent re in rge.Children)
{
if (re is ConditionSingle)
{
numrules++;
}
if (re is ConditionGroup)
{
CountItems((ConditionGroup)re, ref numgroups, ref numrules);
}
}
}
public virtual IEnumerable <T> GetTablePage(int startRecord, int numRecords)
{
var condition = new ConditionGroup(
new Condition(
new NameValuePair("ROW_NR", "@start", NameValuePair.Operator.GreaterOrEquals))
.And(new NameValuePair("ROW_NR", "@end", NameValuePair.Operator.LessOrEquals))
);
var parameters = new SqlParameter[] {
getParameter("start", System.Data.SqlDbType.Int, startRecord),
getParameter("end", System.Data.SqlDbType.Int, startRecord + numRecords)
};
return(GetTable(condition, parameters));
}
public void TestClone_MaintainsParentChildRelationship()
{
Condition condition = new Condition(Guid.NewGuid(), "className", OperatorType.LessThan);
Condition condition2 = new Condition(Guid.NewGuid(), "className", OperatorType.LessThan);
ConditionGroup group = new ConditionGroup();
group.Conditions.Add(condition);
group.Conditions.Add(condition2);
IConditionGroup copyOfGroup = group.Clone() as IConditionGroup;
Assert.IsNotNull(copyOfGroup);
Assert.AreEqual(2, group.Conditions.Count);
Assert.AreEqual(copyOfGroup, ((ICondition)copyOfGroup.Conditions[0]).Parent);
Assert.AreEqual(copyOfGroup, ((ICondition)copyOfGroup.Conditions[1]).Parent);
}
public ICondition GetCondition(Dictionary <string, string> tableAliasesByFieldPath)
{
ConditionGroup conditionGroup = new ConditionGroup();
if (SearchConditionGroupType == SearchConditionGroupTypes.And)
{
conditionGroup.ConditionGroupType = ConditionGroup.ConditionGroupTypes.And;
}
else
{
conditionGroup.ConditionGroupType = ConditionGroup.ConditionGroupTypes.Or;
}
conditionGroup.Conditions.AddRange(SearchConditions.Select(sc => sc.GetCondition(tableAliasesByFieldPath)));
return(conditionGroup);
}
private static SIF_ConditionGroup createConditionGroup(Query query, SifVersion effectiveVersion)
{
// Create the hierarchy SIF_ConditionGroup
// > SIF_Conditons
// > SIF_Condition
// From
// ConditionGroup
// > [ConditionGroup (Optional)]
// > Condition
SIF_ConditionGroup returnGroup = new SIF_ConditionGroup();
returnGroup.Type = ConditionType.NONE.ToString();
ConditionGroup cg = query.RootConditionGroup;
ConditionGroup[] groups = cg.Groups;
if (groups != null && groups.Length > 0)
{
//
// There's one or more ConditionGroups...
// These get translated to SIF_Conditions elements
//
if (cg.Operator == GroupOperator.Or)
{
returnGroup.Type = ConditionType.OR.ToString();
}
else if (cg.Operator == GroupOperator.And)
{
returnGroup.Type = ConditionType.AND.ToString();
}
foreach (ConditionGroup group in groups)
{
returnGroup.AddSIF_Conditions(createConditions(query, group, effectiveVersion));
}
}
else
{
//
// There are no SIF_Conditions groups, so build one...
//
returnGroup.AddSIF_Conditions(createConditions(query, cg, effectiveVersion));
}
return(returnGroup);
}
void SelectBlock(SelectExpression expression) {
Expect(28);
if (la.kind == 2) {
SelectPart(expression);
while (la.kind == 16) {
Get();
SelectPart(expression);
}
} else if (la.kind == 29) {
Get();
var sel = new ExpressionGeneration.SelectDescriptor(); sel.Star = true;
} else SynErr(41);
Expect(27);
if (la.kind == 2) {
FromSource(expression);
} else if (la.kind == 28) {
var subexpression = new SelectExpression();
SelectBlock(subexpression);
expression.SetFrom(subexpression);
} else SynErr(42);
if (la.kind == 14 || la.kind == 17 || la.kind == 31) {
OrderLimitClause(expression);
}
if (la.kind == 14) {
Get();
ConditionGroup conditions = new ConditionGroup(); expression.SetChild(conditions);
Conditional(conditions);
while (StartOf(1)) {
Conditional(conditions);
}
}
if (la.kind == 17 || la.kind == 31) {
OrderLimitClause(expression);
}
if (la.kind == 31) {
Get();
Expect(19);
Expect(2);
expression.AddDimension(t.val);
while (la.kind == 16) {
Get();
Expect(2);
expression.AddDimension(t.val);
}
OrderLimitClause(expression);
}
}
void ConditionGroup(SingleNodeTree parent) {
ConditionGroup group = new ConditionGroup(); parent.SetChild(group); ExpressionTreeBase addTo = group; SingleNodeTree condition = null; ConditionalExpression lastOperation = null;
Expect(6);
while (StartOf(2)) {
lastOperation = lastOperation ?? new AndCondition();
MultiAdd(addTo, lastOperation);
addTo = lastOperation;
if (la.kind == 5) {
Get();
NotCondition not = new NotCondition(); lastOperation.SetChild(not); lastOperation = not;
}
if (StartOf(3)) {
Condition(lastOperation);
} else if (la.kind == 6) {
ConditionGroup(lastOperation);
} else SynErr(47);
if (la.kind == 9 || la.kind == 10) {
Operation(out lastOperation);
}
else { lastOperation = null; }
}
if (lastOperation != null && lastOperation.Child == null) SemErr("Invalid Condition");
Expect(7);
}
void ComplexCondition(SingleNodeTree parent, SelectorExpression selector) {
ConditionGroup group = new ConditionGroup(); parent.SetChild(group); ExpressionTreeBase addTo = group; SingleNodeTree condition = null; ConditionalExpression lastOperation = null;
Expect(6);
while (StartOf(2)) {
lastOperation = lastOperation ?? new AndCondition();
MultiAdd(addTo, lastOperation);
addTo = lastOperation;
selector = new SelectorExpression(selector.Field, ModifierTypes.Equals, selector.Path);
if (la.kind == 5) {
Get();
NotCondition not = new NotCondition(); lastOperation.SetChild(not); lastOperation = not;
}
if (la.kind == 6) {
ComplexCondition(lastOperation, selector);
} else if (StartOf(3)) {
SelectorExpression nestedSelector = new SelectorExpression(selector.Field, ModifierTypes.Equals, selector.Path); MultiAdd(lastOperation, nestedSelector);
Literal(nestedSelector);
} else SynErr(49);
if (la.kind == 9 || la.kind == 10) {
Operation(out lastOperation);
}
else { lastOperation = null; }
}
Expect(7);
}
private void OnAddExpression(ConditionGroup group)
{
var propertyExpression = new PropertyExpression();
propertyExpression.Property = InstanceProperties.FirstOrDefault();
group.Items.Add(propertyExpression);
propertyExpression.Parent = group;
}
private void OnAddGroup(ConditionGroup group)
{
var newGroup = new ConditionGroup();
group.Items.Add(newGroup);
newGroup.Parent = group;
}
private static SIF_Conditions createConditions(Query query, ConditionGroup group, SifVersion effectiveVersion)
{
ConditionType typ = ConditionType.NONE;
if (group.Operator == GroupOperator.And)
{
typ = ConditionType.AND;
}
else if (group.Operator == GroupOperator.Or)
{
typ = ConditionType.OR;
}
Condition[] conditions = group.Conditions;
SIF_Conditions conds = new SIF_Conditions(conditions.Length > 1 ? typ : ConditionType.NONE);
foreach (Condition c in conditions)
{
conds.AddSIF_Condition(
c.GetXPath(query, effectiveVersion),
Operators.Wrap(c.Operators.ToString()),
c.Value);
}
return conds;
}
/// <summary>
/// 条件分组
/// </summary>
/// <param name="relation">组与组间的关系</param>
/// <param name="condition">添加条件或组</param>
/// <param name="conditions">可选参数，可以添加多个条件和组</param>
/// <returns></returns>
public static ConditionGroup Group(ConditionRelation relation, ICondition condition, params ICondition[] conditions)
{
ConditionGroup group = new ConditionGroup(relation, condition, conditions);
return group;
}
/// <summary>
/// 条件分组
/// </summary>
/// <param name="condition">添加条件或组</param>
/// <param name="conditions">可选参数，可以添加多个条件和组</param>
/// <returns></returns>
public static ConditionGroup Group(ICondition condition, params ICondition[] conditions)
{
ConditionGroup group = new ConditionGroup(condition, conditions);
return group;
}
