public StateVersionPattern(GenieLampConfig owner, XmlNode node)
: base(owner, node)
{
attributeName = Params.ValueByName("Attribute.Name", attributeName);
typeName = Params.ValueByName("Attribute.Type", typeName);
unsavedValue = Params.ValueByName("UnsavedValue", unsavedValue);
}
internal ServicesLayerConfig(GenieLampConfig owner)
: base(owner, LayerName)
{
if (BaseNamespace == Const.EmptyName)
{
throw new GlException("Services layer configuration: base namespace is empty or parameter is not defined.");
}
}
public AuditPattern(GenieLampConfig owner, XmlNode node)
: base(owner, node)
{
attributesPrefix = Params.ValueByName("AttributesPrefix", attributesPrefix);
this.CreatedByAttributeName = attributesPrefix + "CreatedBy";
this.CreatedDateAttributeName = attributesPrefix + "CreatedDate";
this.LastModifiedByAttributeName = attributesPrefix + "LastModifiedBy";
this.LastModifiedDateAttributeName = attributesPrefix + "LastModifiedDate";
}
private void Init(GenieLampConfig owner, string name)
{
this.owner = owner;
this.name = name;
namingConvention = new NamingConvention(this);
layerConfigParams = new LayerConfigParams(this);
macro = new MacroExpander(owner.Macro);
this.Keywords = new LayerKeywords();
this.LocalizationParams = new LayerLocalizationParams(this);
}
public RegistryPattern(GenieLampConfig owner, XmlNode node)
: base(owner, node)
{
registryEntityName = Params.ValueByName("RegistryEntity.Name", registryEntityName);
typesEntityName = Params.ValueByName("TypesEntity.Name", typesEntityName);
primaryIdTypeName = Params.ValueByName("PrimaryId.Type", primaryIdTypeName);
typesEntityPidTypeName = Params.ValueByName("TypesEntity.PrimaryId.Type", typesEntityPidTypeName);
if (String.IsNullOrEmpty(Schema))
{
throw new GlException("Registry pattern requires schema specification");
}
}
public PatternConfig(GenieLampConfig owner, XmlNode node)
{
this.owner = owner;
this.name = Utils.Xml.GetAttrValue(node, "name");
this.OnPersistentLayer = bool.Parse(Utils.Xml.GetAttrValue(node, "onPersistentLayer"));
macro = new MacroExpander(owner.Macro);
this.PatternApply = new PatternApply(owner);
configParams = new PatternConfigParams(this, owner.Lamp.QueryNode(node, "./{0}:Param"));
this.schema = Params.ValueByName("Schema", this.schema);
this.PersistentSchemaDefined = Params.ParamByName("PersistentSchema", false) != null;
this.persistentSchema = Params.ValueByName("PersistentSchema", this.persistentSchema);
AddPatternApplyItems(owner.Lamp.QueryNode(node, "./{0}:Exclude"), PatternApplyMode.Exclude);
AddPatternApplyItems(owner.Lamp.QueryNode(node, "./{0}:Include"), PatternApplyMode.Include);
}
public LayerConfig(GenieLampConfig owner, XmlNode node)
{
Init(owner, Utils.Xml.GetAttrValue(node, "name"));
isDefined = true;
this.subname = Utils.Xml.GetAttrValue(node, "subname", Const.EmptyName);
XmlNodeList namingConvNodes = owner.Lamp.QueryNode(node, "./{0}:NamingConvention");
if (namingConvNodes.Count == 0)
{
namingConvention = new NamingConvention(this);
}
else
{
namingConvention = new NamingConvention(this, namingConvNodes[0]);
}
layerConfigParams = new LayerConfigParams(this, owner.Lamp.QueryNode(node, "./{0}:Param"));
this.LocalizationParams = new LayerLocalizationParams(this, owner.Lamp.QueryNode(node, "./{0}:Localization/{0}:Param"));
}
public LayersConfig(GenieLampConfig owner, XmlNode node)
: base()
{
XmlNodeList nodeList = owner.Lamp.QueryNode(node, "./{0}:Layer");
foreach (XmlNode layerNode in nodeList)
{
LayerConfig layer = new LayerConfig(owner, layerNode);
if (layer.FullName.Equals(PersistenceLayerConfig.LayerName, StringComparison.InvariantCultureIgnoreCase))
{
persistenceConfig = new PersistenceLayerConfig(owner, layerNode);
}
else if (layer.FullName.Equals(DomainLayerConfig.LayerName, StringComparison.InvariantCultureIgnoreCase))
{
domainConfig = new DomainLayerConfig(owner, layerNode);
}
else if (layer.FullName.Equals(ServicesLayerConfig.LayerName, StringComparison.InvariantCultureIgnoreCase))
{
servicesConfig = new ServicesLayerConfig(owner, layerNode);
}
this.Add(layer.FullName, layer);
}
if (persistenceConfig == null)
{
owner.Lamp.Logger.Warning(WarningLevel.Medium, "Persistent layer configuration was not found");
persistenceConfig = new PersistenceLayerConfig(owner);
}
if (domainConfig == null)
{
owner.Lamp.Logger.Warning(WarningLevel.Medium, "Domain layer configuration was not found");
domainConfig = new DomainLayerConfig(owner);
}
if (servicesConfig == null)
{
owner.Lamp.Logger.Warning(WarningLevel.Medium, "Services layer configuration was not found");
servicesConfig = new ServicesLayerConfig(owner);
}
}
public PersistenceLayerConfig(GenieLampConfig owner, XmlNode node)
: base(owner, node)
{
Init();
ParamSimple booleanValues = this.Params.GetByName("BooleanValues", false);
if (booleanValues != null)
{
switch (booleanValues.Value.ToLower())
{
case "native":
break;
case "truefalse":
this.BooleanValuePersistence = BooleanValuePersistence.TrueFalse;
break;
case "yesno":
this.BooleanValuePersistence = BooleanValuePersistence.YesNo;
break;
}
}
}
public Patterns(GenieLampConfig owner, XmlNode node)
: base()
{
XmlNodeList nodeList = owner.Lamp.QueryNode(node, "./{0}:Pattern");
foreach (XmlNode patternNode in nodeList)
{
PatternConfig pattern;
string patternName = Utils.Xml.GetAttrValue(patternNode, "name");
if (patternName.Equals(RegistryPattern.NodeName, StringComparison.InvariantCultureIgnoreCase))
{
pattern = this.Registry = new RegistryPattern(owner, patternNode);
}
else if (patternName.Equals(StateVersionPattern.NodeName, StringComparison.InvariantCultureIgnoreCase))
{
pattern = this.StateVersion = new StateVersionPattern(owner, patternNode);
}
else if (patternName.Equals(AuditPattern.NodeName, StringComparison.InvariantCultureIgnoreCase))
{
pattern = this.Audit = new AuditPattern(owner, patternNode);
}
else if (patternName.Equals(LocalizationPattern.NodeName, StringComparison.InvariantCultureIgnoreCase))
{
pattern = this.Localization = new LocalizationPattern(owner, patternNode);
}
else if (patternName.Equals(SecurityPattern.NodeName, StringComparison.InvariantCultureIgnoreCase))
{
pattern = this.Security = new SecurityPattern(owner, patternNode);
}
else
{
pattern = new PatternConfig(owner, patternNode);
}
this.Add(pattern.Name, pattern);
}
}
public LocalizationPattern(GenieLampConfig owner, XmlNode node)
: base(owner, node)
{
}
public ServicesLayerConfig(GenieLampConfig owner, XmlNode node)
: base(owner, node)
{
}
public PatternApply(GenieLampConfig owner)
{
this.owner = owner;
}
public SecurityPattern(GenieLampConfig owner, XmlNode node)
: base(owner, node)
{
}
internal LayerConfig(GenieLampConfig owner, string name)
{
Init(owner, name);
}
internal PersistenceLayerConfig(GenieLampConfig owner)
: base(owner, LayerName)
{
Init();
}
public DomainLayerConfig(GenieLampConfig owner, XmlNode node)
: base(owner, node)
{
mappingStrategy = ToMappingStrategy(Params.ValueByName("MappingStrategy", Const.EmptyName));
}
