public static void Buildrule(CollectionRule aRule, String genericType, IDataRule valueRule, IDataRule keyRule, String assembly, String assemblyPath)
{
aRule.Assembly = assembly;
aRule.Assembly = assemblyPath;
aRule.Generic = EnumPlus.ConvertString(typeof(GenericCollections), genericType);
aRule.ValueRule = valueRule;
aRule.KeyRule = keyRule;
}
public override void EditRule(IDataRule aRule)
{
base.EditRule(aRule);
CollectionRule cRule = (CollectionRule)aRule;
keyRule = cRule.KeyRule;
valueRule = cRule.ValueRule;
int idx = collectionTypes.Items.IndexOf(cRule.Generic.ToString());
if (idx != -1)
{
collectionTypes.SelectedIndex = idx;
}
}
private void EditRules(IDataRule aRule)
{
CollectionRule cRule = (CollectionRule)aRule;
if (cRule.KeyRule != null)
{
collectionsCtrl.SetRule(cRule.KeyRule, true);
lblKeyRule.Text = SetType(cRule.KeyRule);
lblKeyRule.Tag = cRule.KeyRule;
}
collectionsCtrl.SetRule(cRule.ValueRule, false);
lblValueRule.Text = SetType(cRule.ValueRule);
lblValueRule.Tag = cRule.ValueRule;
aCollection = cRule.Generic;
}
public static IDataRule InitializeBase(FieldTypes generalType, bool isRandom, String fieldName, String fieldDataType, bool convertToString)
{
IDataRule result = null;
switch (generalType)
{
case FieldTypes.Date:
result = new DateRule();
break;
case FieldTypes.Time:
result = new TimeRule();
break;
case FieldTypes.GUID:
result = new GuidRule();
break;
case FieldTypes.Imported:
//result = new
break;
case FieldTypes.MultiColumn:
result = new MultiFieldDataSourceRule();
break;
case FieldTypes.SingleColumn:
result = new SingleFieldDataSourceRule();
break;
case FieldTypes.Number:
result = new NumberRule();
break;
case FieldTypes.String:
result = new StringRule();
break;
case FieldTypes.Bool:
result = new BoolRule();
break;
case FieldTypes.Dynamic:
case FieldTypes.Type:
result = new TRule();
break;
case FieldTypes.Enumerator:
result = new EnumeratorRule();
break;
case FieldTypes.MappedSource:
result = new MappedSourceRule();
break;
case FieldTypes.Collection:
result = new CollectionRule();
break;
case FieldTypes.Tuple:
result = new TupleRule();
break;
}
result.ConvertToString = convertToString;
result.FieldDataType = fieldDataType;
result.FieldName = fieldName;
result.IsRandom = isRandom;
result.RuleType = generalType;
return(result);
}
private bool TryCreateActivationRuleInternal(XmlNode node, out ActivationRule activationRule)
{
activationRule = null;
if (node == null || node.Attributes == null)
{
return(false);
}
XmlAttribute xmlAttribute = node.Attributes["type", "http://www.w3.org/2001/XMLSchema-instance"];
string a;
if (!ExtensionDataHelper.TryGetNameSpaceStrippedAttributeValue(xmlAttribute, out a))
{
return(false);
}
if (!string.Equals(a, "ItemIs", StringComparison.Ordinal))
{
if (string.Equals(a, "ItemHasKnownEntity", StringComparison.Ordinal))
{
KnownEntityType entityType;
if (EnumValidator.TryParse <KnownEntityType>(node.Attributes["EntityType"].Value, EnumParseOptions.Default, out entityType))
{
XmlAttribute xmlAttribute2 = node.Attributes["FilterName"];
XmlAttribute xmlAttribute3 = node.Attributes["RegExFilter"];
bool ignoreCase = SchemaParser.ParseBoolFromXmlAttribute(node.Attributes["IgnoreCase"]);
activationRule = new ItemHasKnownEntityRule(entityType, (xmlAttribute2 != null) ? xmlAttribute2.Value : null, (xmlAttribute3 != null) ? xmlAttribute3.Value : null, ignoreCase);
return(true);
}
}
else if (string.Equals(a, "ItemHasRegularExpressionMatch", StringComparison.Ordinal))
{
RegExPropertyName propertyName;
if (EnumValidator.TryParse <RegExPropertyName>(node.Attributes["PropertyName"].Value, EnumParseOptions.Default, out propertyName))
{
bool ignoreCase2 = SchemaParser.ParseBoolFromXmlAttribute(node.Attributes["IgnoreCase"]);
activationRule = new ItemHasRegularExpressionMatchRule(node.Attributes["RegExName"].Value, node.Attributes["RegExValue"].Value, propertyName, ignoreCase2);
return(true);
}
}
else
{
if (string.Equals(a, "ItemHasAttachment", StringComparison.Ordinal))
{
activationRule = new ItemHasAttachmentRule();
return(true);
}
if (node.ChildNodes != null && 0 < node.ChildNodes.Count && string.Equals(a, "RuleCollection", StringComparison.Ordinal))
{
ActivationRule[] array = new ActivationRule[node.ChildNodes.Count];
int num = 0;
foreach (object obj in node.ChildNodes)
{
XmlNode xmlNode = (XmlNode)obj;
ActivationRule activationRule2;
if (this.IsExpectedOweNamespace(xmlNode.NamespaceURI) && string.Equals(xmlNode.LocalName, "Rule", StringComparison.Ordinal) && this.TryCreateActivationRuleInternal(xmlNode, out activationRule2))
{
array[num++] = activationRule2;
}
}
xmlAttribute = node.Attributes["Mode"];
activationRule = new CollectionRule((xmlAttribute == null) ? "Or" : xmlAttribute.Value, array);
return(true);
}
}
return(false);
}
ItemIsRuleItemType itemType;
if (EnumValidator.TryParse <ItemIsRuleItemType>(node.Attributes["ItemType"].Value, EnumParseOptions.Default, out itemType))
{
XmlAttribute xmlAttribute4 = node.Attributes["FormType"];
ItemIsRuleFormType formType;
if (xmlAttribute4 == null || !EnumValidator.TryParse <ItemIsRuleFormType>(xmlAttribute4.Value, EnumParseOptions.Default, out formType))
{
formType = ItemIsRuleFormType.Read;
}
bool includeSubClasses = SchemaParser.ParseBoolFromXmlAttribute(node.Attributes["IncludeSubClasses"]);
XmlAttribute xmlAttribute5 = node.Attributes["ItemClass"];
activationRule = new ItemIsRule(itemType, (xmlAttribute5 != null) ? xmlAttribute5.Value : null, includeSubClasses, formType);
return(true);
}
return(false);
}
