public static ArrayList ParseFromXml(XmlNode root, IList entities, IPropertyContainer container, Hashtable sqltypes, Hashtable types, ParserValidationDelegate vd)
{
ArrayList comparers = new ArrayList();
XmlNode comparerNode = GetChildNodeByName(root, COMPARERS);
if (comparerNode != null)
{
foreach (XmlNode node in comparerNode.ChildNodes)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
ComparerElement comparer = new ComparerElement();
if (node.Attributes["name"] == null)
{
vd(ParserValidationArgs.NewError("ComparerElement in " + container.Name + " has no name attribute."));
continue;
}
comparer.Name = node.Attributes["name"].Value;
comparer.Fields = PropertyElement.ParseFromXml(GetChildNodeByName(node, PROPERTIES), new ArrayList(), container, sqltypes, types, true, vd);
comparers.Add(comparer);
}
}
return(comparers);
}
/// <summary>
/// Adds references for all properties if * name is found.
/// </summary>
/// <param name="vd"></param>
private void ProcessAsteriskName(ParserValidationDelegate vd)
{
ArrayList asteriskNames = new ArrayList();
foreach (PropertyElement p in propertyReferences)
{
if (p.Name == "*")
{
asteriskNames.Add(p);
}
}
if (asteriskNames.Count > 1)
{
vd(ParserValidationArgs.NewError("More than one name of asterisk(*) was specified for Entity Reference " + this.Name + " in " + this.ReportExtraction.Name + "."));
}
if (asteriskNames.Count > 0)
{
foreach (PropertyElement p in asteriskNames)
{
propertyReferences.Remove(p);
}
PropertyElement allReference = (PropertyElement)asteriskNames[0];
if (allReference.GroupFunction != String.Empty &&
allReference.GroupFunction.ToLower() != PropertyElement.GROUP_FUNCTION_MIN &&
allReference.GroupFunction.ToLower() != PropertyElement.GROUP_FUNCTION_MAX)
{
vd(ParserValidationArgs.NewError("The property with name of * may only have group functions of min or max. Error in entity refeence " + this.Name + " in report extraction " + this.ReportExtraction.Name + "."));
}
foreach (PropertyElement p in this.Entity.Fields)
{
bool found = false;
foreach (PropertyElement pr in this.PropertyReferences)
{
if (pr.Name == p.Name)
{
found = true;
break;
}
}
if (!found)
{
PropertyElement entityReferencePropertyElement = new PropertyElement();
entityReferencePropertyElement.GroupFunction = allReference.GroupFunction;
entityReferencePropertyElement.Name = p.Name;
entityReferencePropertyElement.AccessModifier = p.AccessModifier;
entityReferencePropertyElement.Column = (ColumnElement)(p.Column.Clone());
entityReferencePropertyElement.ConcreteType = p.ConcreteType;
entityReferencePropertyElement.ConvertFromSqlTypeFormat = p.ConvertFromSqlTypeFormat;
entityReferencePropertyElement.Type = p.Type;
this.PropertyReferences.Add(entityReferencePropertyElement);
}
}
}
}
public static ArrayList ParseFromXml(XmlDocument doc, IList entities, EntityElement entity, Hashtable sqltypes, Hashtable types, bool isReference, ParserValidationDelegate vd)
{
XmlNodeList elements = doc.DocumentElement.GetElementsByTagName("entity");
foreach (XmlNode element in elements)
{
String name = element.Attributes["name"].Value;
String sqlEntity = (element.Attributes["sqlentity"] == null) ? String.Empty : element.Attributes["sqlentity"].Value;
// if ((sqlEntity.Equals(entity.SqlEntity.Name) || (entity.SqlEntity.Name.Length == 0 && name == entity.Name)) && element.HasChildNodes) {
if (name.Equals(entity.Name) && element.HasChildNodes)
{
// look for a properties element, if one does not exist, assume that everything under the entity is a property (for backward compatablility)
XmlNode propertiesNode = element;
Boolean hasProperties = false;
foreach (XmlNode node in element.ChildNodes)
{
if (node.Name.Equals("properties"))
{
propertiesNode = node;
hasProperties = true;
}
}
if (!hasProperties)
{
vd(ParserValidationArgs.NewError("<property> elements on entity (" + entity.Name + ") should be defined within a <properties> element."));
}
return(ParseFromXml(propertiesNode, entities, entity, sqltypes, types, isReference, vd));
}
}
return(new ArrayList());
}
public static Hashtable ParseFromXml(XmlDocument doc, ParserValidationDelegate vd)
{
Hashtable sqltypes = new Hashtable();
XmlNodeList elements = doc.DocumentElement.GetElementsByTagName("sqltype");
foreach (XmlNode node in elements)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
SqlTypeElement sqltype = new SqlTypeElement();
sqltype.Name = node.Attributes["name"].Value;
sqltype.SqlDbType = sqltype.Name.Substring(0, 1).ToUpper() + sqltype.Name.Substring(1);
if (node.Attributes["type"] != null)
{
sqltype.Type = node.Attributes["type"].Value;
}
if (node.Attributes["length"] != null)
{
sqltype.Length = Int32.Parse(node.Attributes["length"].Value);
}
if (node.Attributes["scale"] != null)
{
sqltype.Scale = Int32.Parse(node.Attributes["scale"].Value);
}
if (node.Attributes["precision"] != null)
{
sqltype.Precision = Int32.Parse(node.Attributes["precision"].Value);
}
if (node.Attributes["readermethodformat"] != null)
{
sqltype.ReaderMethodFormat = node.Attributes["readermethodformat"].Value;
}
if (node.Attributes["sqldbtype"] != null)
{
sqltype.SqlDbType = node.Attributes["sqldbtype"].Value;
}
if (node.Attributes["dbtype"] != null)
{
sqltype.DbType = node.Attributes["dbtype"].Value;
}
if (node.Attributes["declarationformat"] != null)
{
sqltype.DeclarationFormat = node.Attributes["declarationformat"].Value;
}
if (sqltypes.ContainsKey(sqltype.Name))
{
vd(ParserValidationArgs.NewWarning("Ignoring duplicate definition of sqltype: " + sqltype.Name));
}
else
{
sqltypes.Add(sqltype.Name, sqltype);
}
}
return(sqltypes);
}
/// <summary>
/// Second pass parse and validation.
/// </summary>
/// <param name="options">Configuration options.</param>
/// <param name="doc">Document being parsed.</param>
/// <param name="sqltypes">List of sql types defined.</param>
/// <param name="types">List of .Net types defined.</param>
/// <param name="entities">List of EntityElement objects defined.</param>
/// <param name="vd">Validation delegate for error reporting.</param>
/// <returns>Validated list of report extractions.</returns>
public static ArrayList ParseFromXml(Configuration options, XmlDocument doc, Hashtable sqltypes, Hashtable types, IList entities, ParserValidationDelegate vd)
{
ArrayList reportExtractions = new ArrayList();
XmlNodeList elements = doc.DocumentElement.GetElementsByTagName("reportextraction");
foreach (XmlNode node in elements)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
ReportExtractionElement reportExtraction = new ReportExtractionElement();
if (node.Attributes[NAME] != null)
{
reportExtraction.Name = node.Attributes[NAME].Value;
}
else
{
vd(ParserValidationArgs.NewError("A report extraction must have a name."));
}
if (node.Attributes[HINTS] != null)
{
reportExtraction.Hints = (string)(node.Attributes[HINTS].Value);
}
if (node.Attributes[HAVING] != null)
{
reportExtraction.Having = (string)(node.Attributes[HAVING].Value);
}
reportExtraction.EntityReferences = EntityReferenceElement.ParseFromXml(options, GetChildNodeByName(node, ENTITY_REFERENCES), reportExtraction, types, sqltypes, entities, vd);
XmlNode computedProperties = GetChildNodeByName(node, COMPUTED_PROPERTIES);
if (computedProperties != null)
{
reportExtraction.ComputedProperties = PropertyElement.ParseFromXml(computedProperties, entities, reportExtraction, sqltypes, types, false, vd);
}
reportExtraction.ValidateFilters(vd);
reportExtraction.ValidateExpressions(vd);
reportExtraction.ValidateUniqueNames(vd);
reportExtraction.ValidateDatabases(vd);
reportExtractions.Add(reportExtraction);
reportExtraction.Having = Configuration.PrepareExpression(reportExtraction.Having, reportExtraction, "having attribute in report extraction " + reportExtraction.Name, vd);
// Make sure finders get prepared expressions!
reportExtraction.Comparers = ComparerElement.ParseFromXml(node, entities, reportExtraction, sqltypes, types, vd);
reportExtraction.Finders = ReportExtractionFinderElement.ParseFromXml(node, entities, reportExtraction, sqltypes, types, vd);
}
return(reportExtractions);
}
public static ArrayList ParseFromXml(Configuration options, XmlDocument doc, Hashtable sqltypes, Hashtable types, ParserValidationDelegate vd)
{
ArrayList enums = new ArrayList();
XmlNodeList elements = doc.DocumentElement.GetElementsByTagName("enum");
foreach (XmlNode node in elements)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
EnumElement type = new EnumElement();
type.Name = node.Attributes["name"].Value;
// TODO: this returns all of the children node's innerText as well
//type.Description = StringUtil.RemoveTrailingBlankLines(node.InnerText.Trim());
if (node.Attributes["template"] != null)
{
type.Template = node.Attributes["template"].Value;
}
if (node.Attributes["integerbased"] != null)
{
type.IntegerBased = Boolean.Parse(node.Attributes["integerbased"].Value);
}
type.Values = EnumValueElement.ParseFromXml(type.Name, options, doc, sqltypes, types, vd);
// if IsIntegerBased - validate that all values are parsable by Int32
if (type.IntegerBased)
{
foreach (EnumValueElement v in type.Values)
{
try {
Int32.Parse(v.Code);
} catch (Exception) {
// parse error - must not be an Int32
vd(ParserValidationArgs.NewError("IntegerBased was set for enum " + type.Name + " and code '" + v.Code + "' was not parsable by Int32."));
}
}
}
enums.Add(type);
}
return(enums);
}
/// <summary>
/// Validates that the expressions for the computed properties refer to embedded properties correctly.
/// Also sets up the SQL Alias's
/// </summary>
/// <param name="vd">Validation delegate for error reporting.</param>
private void ValidateExpressions(ParserValidationDelegate vd)
{
foreach (PropertyElement p in ComputedProperties)
{
p.Column.Name = p.Name;
if (p.Expression == String.Empty)
{
vd(ParserValidationArgs.NewError("The computed property " + p.Name + " in report extraction " + this.Name + " has no expression."));
}
else
{
p.Expression = Configuration.PrepareExpression(p.Expression, this, "expression for property " + p.Name + " in report extraction " + this.Name, vd);
}
if (p.Column.SqlType.Name == String.Empty)
{
vd(ParserValidationArgs.NewError("The computed property " + p.Name + " in report extraction " + this.Name + " has no sql type defined."));
}
}
}
/// <summary>
/// Validates that the report extraction does not cross database boundaries.
/// </summary>
/// <param name="vd">Validation delegate for error reporting.</param>
private void ValidateDatabases(ParserValidationDelegate vd)
{
string firstKey = String.Empty;
foreach (EntityReferenceElement e in EntityReferences)
{
if (e.Entity.SqlEntity.Name != String.Empty)
{
if (firstKey == String.Empty)
{
firstKey = e.Entity.SqlEntity.Key;
}
else if (e.Entity.SqlEntity.Name != String.Empty && e.Entity.SqlEntity.Key != firstKey)
{
vd(ParserValidationArgs.NewError("All entity references in the report extraction" + this.Name + " must refer to entities whose sql entities all have the same key."));
break;
}
}
}
}
public static string PrepareExpression(string withEmbedded, IExpressionContainer container, string idString, ParserValidationDelegate vd)
{
string checkExpression = withEmbedded;
string retVal = String.Empty;
int leftBrace = 0;
int startPos = 0;
for (leftBrace = checkExpression.IndexOf("{", startPos); startPos >= 0; leftBrace = checkExpression.IndexOf("{", startPos))
{
if (leftBrace == -1)
{
// No more strings to replace.
retVal += checkExpression.Substring(startPos, checkExpression.Length - startPos);
break;
}
else
{
// Concatenate portion of string without embedded references.
retVal += checkExpression.Substring(startPos, leftBrace - startPos);
}
int rightBrace = checkExpression.IndexOf("}", leftBrace);
if (rightBrace == -1)
{
if (vd != null)
{
vd(ParserValidationArgs.NewError("The " + idString + " has a left brace({} with no corresonding right brace(}}"));
}
return("");
}
// Isolate the property reference and concatenate it's expansion.
string expressionReference = checkExpression.Substring(leftBrace + 1, rightBrace - leftBrace - 1);
retVal += container.GetExpressionSubstitution(expressionReference, idString, vd);
// On to the next reference.
startPos = rightBrace + 1;
}
return(retVal);
}
public string GetExpressionSubstitution(string substitutionExpression, string idString, ParserValidationDelegate vd)
{
int parm = -1;
try {
parm = Int32.Parse(substitutionExpression);
} catch (Exception) {
}
if (parm > -1)
{
if (parm >= fields.Count)
{
if (vd != null)
{
vd(ParserValidationArgs.NewError("Substitution string " + substitutionExpression + " in " + idString + " refers to a parameter number larger that the number of parameters."));
}
return("");
}
String param = "@" + ((PropertyElement)(this.Fields[parm])).GetPropertyName();
return(param.Replace(".", "_"));
}
else
{
PropertyElement p = this.container.FindFieldByName(substitutionExpression);
if (p == null)
{
if (vd != null)
{
vd(ParserValidationArgs.NewError("Substitution string " + substitutionExpression + " in " + idString + " refers to a property that does not occur in the finder's entity."));
}
return("");
}
else
{
return(GetSqlExpression(p));
}
}
}
public static ArrayList ParseFromXml(Configuration options, XmlDocument doc, Hashtable sqltypes, Hashtable types, ParserValidationDelegate vd)
{
DatabaseElement defaults = new DatabaseElement();
XmlNodeList elements = doc.DocumentElement.GetElementsByTagName("databases");
if (elements.Count < 1)
{
vd(ParserValidationArgs.NewError("No databases tags found. You must have at least one databases tag."));
}
else
{
SqlEntityElement.ParseNodeAttributes(elements[0], defaults);
}
// loop through each 'database' tag in the xml file (ex: file=dtg-databases.xml)
ArrayList list = new ArrayList();
elements = doc.DocumentElement.GetElementsByTagName("database");
foreach (XmlNode node in elements)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
DatabaseElement database = new DatabaseElement(defaults);
SqlEntityElement.ParseNodeAttributes(node, database);
if (node.Attributes["key"] != null)
{
database.Key = node.Attributes["key"].Value;
}
database.SqlEntities = SqlEntityElement.ParseFromXml(database, GetSqlEntitiesNode(node), sqltypes, types, vd);
list.Add(database);
}
return(list);
}
/// <summary>
/// Second pass parsing and validation.
/// </summary>
/// <param name="options">Configuration options</param>
/// <param name="reportExtractionNode">Node contaiing the entity references.</param>
/// <param name="reportExtraction">ReportExtraction element to contain the parsed entity references.</param>
/// <param name="types">List of .Net types defined.</param>
/// <param name="entities">List of entities defined.</param>
/// <param name="vd">Validation delegate for error reporting.</param>
/// <returns>List of entity references parsed.</returns>
public static ArrayList ParseFromXml(Configuration options, XmlNode reportExtractionNode, ReportExtractionElement reportExtraction, Hashtable types, Hashtable sqltypes, IList entities, ParserValidationDelegate vd)
{
ArrayList entityReferences = new ArrayList();
foreach (XmlNode node in reportExtractionNode.ChildNodes)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
EntityReferenceElement entityReference = new EntityReferenceElement(reportExtraction);
if (entityReference.Name != null)
{
entityReference.Name = node.Attributes[NAME].Value;
}
else
{
vd(ParserValidationArgs.NewError("Entity reference specified in report extraction " + reportExtraction.Name + " with no name."));
}
if (node.Attributes[ENTITY] != null)
{
EntityElement ee = EntityElement.FindEntityByName(entities, node.Attributes[ENTITY].Value);
if (ee != null)
{
entityReference.Entity = ee;
if (entityReference.Entity.SqlEntity.Name == String.Empty)
{
vd(ParserValidationArgs.NewError("Entity Reference " + entityReference.Name + " refers to entity " + node.Attributes[ENTITY].Value + " which does not have an associated SQL entity."));
}
}
else
{
vd(ParserValidationArgs.NewError("Entity Reference " + entityReference.Name + " refers to entity " + node.Attributes[ENTITY].Value + " which does not exist."));
}
}
else
{
vd(ParserValidationArgs.NewError("Entity Reference " + node.Attributes[NAME].Value + " has no entity attribute."));
}
if (node.Attributes[ALIAS_PREFIX] != null)
{
entityReference.aliasPrefix = node.Attributes[ALIAS_PREFIX].Value;
}
if (node.Attributes[HINTS] != null)
{
entityReference.Hints = node.Attributes[HINTS].Value;
}
if (node.Attributes[FILTER] != null)
{
entityReference.Filter = node.Attributes[FILTER].Value;
}
if (node.Attributes[JOIN_MODIFIER] != null)
{
entityReference.JoinModifier = node.Attributes[JOIN_MODIFIER].Value;
if (entityReference.JoinModifier.ToUpper() != JOIN_LEFT &&
entityReference.JoinModifier.ToUpper() != JOIN_RIGHT &&
entityReference.JoinModifier.ToUpper() != JOIN_FULL)
{
vd(ParserValidationArgs.NewError("Entity Reference " + node.Attributes[NAME].Value + " has join modifier other than left, right or full."));
}
}
entityReference.ReportExtraction = reportExtraction;
// Note we pass entityReference.Entity because the fields refer to fields in the entity.
entityReference.propertyReferences = PropertyElement.ParseFromXml(GetChildNodeByName(node, PROPERTY_REFERENCES), entities, entityReference.Entity, sqltypes, types, true, vd);
entityReference.ProcessAsteriskName(vd);
entityReference.AdjustSqlAlias();
entityReferences.Add(entityReference);
}
return(entityReferences);
}
/*
* /// <summary>
* /// Replaces embedded property references in the string with sql cocde.
* /// </summary>
* /// <param name="withEmbedded">Expression to be replaced.</param>
* /// <param name="idString">Id to use when reporting errors.</param>
* /// <param name="vd">Validation delegate for error reporting.</param>
* /// <returns>String with embedded references replaced.</returns>
* private string PrepareExpression(string withEmbedded, string idString, ParserValidationDelegate vd)
* {
* string checkExpression = withEmbedded;
* string retVal = String.Empty;
* int leftBrace = 0;
* int startPos = 0;
* for(leftBrace=checkExpression.IndexOf("{", startPos); startPos >=0; leftBrace=checkExpression.IndexOf("{", startPos))
* {
* if (leftBrace == -1)
* {
* // No more strings to replace.
* retVal += checkExpression.Substring(startPos, checkExpression.Length - startPos);
* break;
* }
* else
* {
* // Concatenate portion of string without embedded references.
* retVal += checkExpression.Substring(startPos, leftBrace - startPos);
* }
* int rightBrace = checkExpression.IndexOf("}", leftBrace);
* if (rightBrace == -1)
* {
* if (vd != null)
* {
* vd(ParserValidationArgs.NewError("The " + idString + " has a left brace({} with no corresonding right brace(}}"));
* }
* return "";
* }
*
* // Isolate the property reference.
* string expression = checkExpression.Substring(leftBrace+1, rightBrace - leftBrace - 1);
*
* // Create list of property references seen to check for circular references.
* ArrayList repeList = new ArrayList();
*
* string[] parts = expression.Split('.');
* string leftPart = "";
* string rightPart = "";
* if (parts.Length == 1)
* {
* // Default the left part to this report extraction if not specified.
* leftPart = this.Name;
* rightPart = parts[0];
* }
* else if (parts.Length == 2)
* {
* leftPart = parts[0];
* rightPart = parts[1];
* }
* else
* {
* if (vd != null)
* {
* vd(ParserValidationArgs.NewError("The expression " + expression + " in the " + idString + " does not contain exactly one dot(.)."));
* }
* return "";
* }
*
*
* if (leftPart.ToLower() == this.Name.ToLower())
* {
* // Refers to a property in this report extraction.
* ReportExtractionPropertyElement repe = this.FindComputedFieldByName(rightPart);
* if (repe != null)
* {
* // Refers to a computed property. Check for circular references.
* foreach(ReportExtractionPropertyElement repel in repeList)
* {
* if(repel.Name == repe.Name)
* {
* if (vd != null)
* {
* vd(ParserValidationArgs.NewError("The expression " + expression + " in the " + idString + " has a circular reference."));
* }
* return "";
* }
* }
*
* // Add in the expansion of this property.e
* retVal += "(" + repe.GetSqlExpression() + ")";
* }
* else
* {
* EntityReferencePropertyElement pre = this.FindReferenceFieldByName(rightPart);
* if (pre != null)
* {
* // Refers to a property reference. Get the expression.
* retVal += pre.GetSqlExpression();
* }
* else
* {
* if (vd != null)
* {
* vd(ParserValidationArgs.NewError("The expression " + expression + " in the " + idString + " refers to a property in the report extraction that does not exist."));
* }
* return "";
* }
* }
* }
* else
* {
* EntityReferenceElement er = FindEntityReferenceByName(leftPart);
* if (er == null)
* {
* if (vd != null)
* {
* vd(ParserValidationArgs.NewError("The expression " + expression + " in the " + idString + " refers to an entity that is not an entity reference in the extraction nor the extraction itself."));
* }
* return "";
* }
* else
* {
* // Refers to an entity reference.
* EntityReferencePropertyElement pre = er.FindFieldBySqlAlias(rightPart);
* if (pre != null)
* {
* // Refers to a property reference in the entity.
* retVal += pre.GetSqlExpression();
* }
* else
* {
* PropertyElement p = er.Entity.FindFieldByName(rightPart);
* if (p != null)
* {
* // Refers to a property in the entity referenced that is not in the property referenced.
* retVal += "[" + er.Name + "].[" + p.Column.Name + "]";
* }
* else
* {
* if (vd != null)
* {
* vd(ParserValidationArgs.NewError("The expression " + expression + " in the " + idString + " refers to a property that is not in the referenced entity reference nor it's associated entity."));
* }
* else
* {
* return "";
* }
* }
* }
* }
* }
*
* startPos = rightBrace + 1;
* }
*
* return retVal;
* }*/
public string GetExpressionSubstitution(string substitutionExpression, string idString, ParserValidationDelegate vd)
{
// Create list of property references seen to check for circular references.
ArrayList repeList = new ArrayList();
string[] parts = substitutionExpression.Split('.');
string leftPart = "";
string rightPart = "";
if (parts.Length == 1)
{
// Default the left part to this report extraction if not specified.
leftPart = this.Name;
rightPart = parts[0];
}
else if (parts.Length == 2)
{
leftPart = parts[0];
rightPart = parts[1];
}
else
{
if (vd != null)
{
vd(ParserValidationArgs.NewError("The expression " + substitutionExpression + " in the " + idString + " does not contain exactly one dot(.)."));
}
return("");
}
if (leftPart.ToLower() == this.Name.ToLower())
{
// Refers to a property in this report extraction.
PropertyElement repe = this.FindComputedFieldByName(rightPart);
if (repe != null)
{
// Refers to a computed property. Check for circular references.
foreach (PropertyElement repel in repeList)
{
if (repel.Name == repe.Name)
{
if (vd != null)
{
vd(ParserValidationArgs.NewError("The expression " + substitutionExpression + " in the " + idString + " has a circular reference."));
}
return("");
}
}
// Add in the expansion of this property.e
return("(" + repe.GetSqlExpression() + ")");
}
else
{
PropertyElement pre = this.FindReferenceFieldByName(rightPart);
if (pre != null)
{
// Refers to a property reference. Get the expression.
return(pre.GetSqlExpression());
}
else
{
if (vd != null)
{
vd(ParserValidationArgs.NewError("The expression " + substitutionExpression + " in the " + idString + " refers to a property in the report extraction that does not exist."));
}
return("");
}
}
}
else
{
EntityReferenceElement er = FindEntityReferenceByName(leftPart);
if (er == null)
{
if (vd != null)
{
vd(ParserValidationArgs.NewError("The expression " + substitutionExpression + " in the " + idString + " refers to an entity that is not an entity reference in the extraction nor the extraction itself."));
}
return("");
}
else
{
// Refers to an entity reference.
PropertyElement pre = er.FindFieldBySqlAlias(rightPart);
if (pre != null)
{
// Refers to a property reference in the entity.
return(pre.GetSqlExpression());
}
else
{
PropertyElement p = er.Entity.FindFieldByName(rightPart);
if (p != null)
{
// Refers to a property in the entity referenced that is not in the property referenced.
return("[" + er.Name + "].[" + p.Column.Name + "]");
}
else
{
if (vd != null)
{
vd(ParserValidationArgs.NewError("The expression " + substitutionExpression + " in the " + idString + " refers to a property that is not in the referenced entity reference nor it's associated entity."));
}
return("");
}
}
}
}
}
public static PropertyElement BuildElement(XmlNode node, Hashtable types, Hashtable sqltypes, IPropertyContainer entity, bool isReference, ParserValidationDelegate vd)
{
PropertyElement field = new PropertyElement();
if (node.Attributes["name"] != null)
{
field.Name = node.Attributes["name"].Value;
}
else
{
vd(ParserValidationArgs.NewError("Property in " + entity.Name + " has no name."));
}
if (isReference && field.Name != "*")
{
PropertyElement refProperty = entity.FindFieldByName(field.Name);
if (refProperty == null)
{
vd(ParserValidationArgs.NewError("Property " + field.Name + " in " + entity.Name + " refers to a property that does not exist."));
}
else
{
field = (PropertyElement)(refProperty.Clone());
}
}
if (node.Attributes["column"] != null)
{
if (node.Attributes["column"].Value.Equals("*"))
{
field.Column.Name = field.Name;
}
else
{
field.Column.Name = node.Attributes["column"].Value;
}
// Column only occurs on entity eement.
SqlEntityElement sqlEntity = ((EntityElement)entity).SqlEntity;
ColumnElement column = sqlEntity.FindColumnByName(field.Column.Name);
if (column != null)
{
field.Column = (ColumnElement)column.Clone();
if (types.Contains(field.Column.SqlType.Type))
{
field.Type = (TypeElement)((TypeElement)types[field.Column.SqlType.Type]).Clone();
}
else
{
vd(ParserValidationArgs.NewError("Type " + field.Column.SqlType.Type + " was not defined [property=" + field.name + "]"));
}
}
else
{
vd(ParserValidationArgs.NewError("column (" + field.Column.Name + ") specified for property (" + field.Name + ") on entity (" + entity.Name + ") was not found in sql entity (" + sqlEntity.Name + ")"));
}
}
field.Description = node.InnerText.Trim();
if (node.Attributes["accessmodifier"] != null)
{
field.AccessModifier = node.Attributes["accessmodifier"].Value;
}
// the concrete type is the *real* type, type can be the same or can be in interface or coersable type
if (node.Attributes["type"] != null)
{
String type = node.Attributes[TYPE].Value;
String concreteType = type;
if (node.Attributes[CONCRETE_TYPE] != null)
{
concreteType = node.Attributes[CONCRETE_TYPE].Value;
}
// if the data type is defined, default it as the property and left be overridden
if (types.Contains(concreteType))
{
field.Type = (TypeElement)((TypeElement)types[concreteType]).Clone();
field.Type.Name = type;
}
else
{
vd(ParserValidationArgs.NewError("Type " + concreteType + " was not defined for property " + field.Name + " in " + entity.Name + "."));
}
String dataObjectTypeName = concreteType + "Data";
if (types.Contains(dataObjectTypeName))
{
field.DataObjectType = (TypeElement)((TypeElement)types[dataObjectTypeName]).Clone();
}
else
{
field.DataObjectType = field.Type;
}
}
if (node.Attributes["convertfromsqltypeformat"] != null)
{
field.Type.ConvertFromSqlTypeFormat = node.Attributes["convertfromsqltypeformat"].Value;
}
if (node.Attributes["converttosqltypeformat"] != null)
{
field.Type.ConvertToSqlTypeFormat = node.Attributes["converttosqltypeformat"].Value;
}
if (node.Attributes[PARAMETER_NAME] != null)
{
field.ParameterName = node.Attributes[PARAMETER_NAME].Value;
}
if (node.Attributes[EXPRESSION] != null)
{
field.Expression = node.Attributes[EXPRESSION].Value;
}
if (node.Attributes[GROUP_FUNCTION] != null)
{
field.GroupFunction = node.Attributes[GROUP_FUNCTION].Value;
if (field.GroupFunction.ToLower() != GROUP_FUNCTION_SUM &&
field.GroupFunction.ToLower() != GROUP_FUNCTION_MIN &&
field.GroupFunction.ToLower() != GROUP_FUNCTION_MAX &&
field.GroupFunction.ToLower() != GROUP_FUNCTION_AVG &&
field.GroupFunction.ToLower() != GROUP_FUNCTION_STDEV &&
field.GroupFunction.ToLower() != GROUP_FUNCTION_STDEVP &&
field.GroupFunction.ToLower() != GROUP_FUNCTION_VAR &&
field.GroupFunction.ToLower() != GROUP_FUNCTION_VARP)
{
vd(ParserValidationArgs.NewError("Invalid group function specified for entity reference property " + field.Name + " in " + entity.Name));
}
}
if (node.Attributes[GROUP_BY] != null)
{
field.GroupBy = Boolean.Parse(node.Attributes[GROUP_BY].Value);
}
if (node.Attributes[SQL_TYPE] != null)
{
field.Column.SqlType.Name = node.Attributes[SQL_TYPE].Value;
if (sqltypes.ContainsKey(field.Column.SqlType.Name))
{
field.Column.SqlType = (SqlTypeElement)((SqlTypeElement)sqltypes[field.Column.SqlType.Name]).Clone();
}
else
{
vd(ParserValidationArgs.NewError("SqlType " + field.Column.SqlType.Name + " was not defined in " + entity.Name + " for property " + field.Name + "."));
}
}
if (node.Attributes[ALIAS] != null)
{
field.Alias = node.Attributes[ALIAS].Value;
}
field.container = entity;
if (node.Attributes["readable"] != null)
{
field.Readable = Boolean.Parse(node.Attributes["readable"].Value);
}
if (node.Attributes["writable"] != null)
{
field.Writable = Boolean.Parse(node.Attributes["writable"].Value);
}
if (node.Attributes["derived"] != null)
{
field.Derived = Boolean.Parse(node.Attributes["derived"].Value);
}
if (node.Attributes["encrypted"] != null)
{
field.Encrypted = Boolean.Parse(node.Attributes["encrypted"].Value);
}
if (node.Attributes["log"] != null)
{
field.DoLog = Boolean.Parse(node.Attributes["log"].Value);
}
if (node.Attributes["returnasidentity"] != null)
{
field.ReturnAsIdentity = Boolean.Parse(node.Attributes["returnasidentity"].Value);
}
if (node.Attributes[DIRECTION] == null)
{
field.Direction = ASCENDING;
}
else if (node.Attributes["direction"].Value != ASCENDING && node.Attributes["direction"].Value != DESCENDING)
{
vd(ParserValidationArgs.NewError("Comparer in entity " + entity.Name + " has direction value other than 'ascending' or 'descending'"));
}
else
{
field.Direction = node.Attributes[DIRECTION].Value;
}
if (node.Attributes[CONVERT_FOR_COMPARE] != null)
{
field.Type.ConvertForCompare = node.Attributes[CONVERT_FOR_COMPARE].Value;
}
if (node.Attributes[USE_ENTITY_DAO] != null)
{
field.UseEntityDao = Boolean.Parse(node.Attributes[USE_ENTITY_DAO].Value);
}
if (node.Attributes["entity"] != null)
{
field.Entity.Name = node.Attributes["entity"].Value;
}
if (node.Attributes["prefix"] != null)
{
field.Prefix = node.Attributes["prefix"].Value;
}
else
{
field.Prefix = field.Entity.Name + "_";
}
return(field);
}
public static ArrayList ParseFromXml(XmlNode propertiesNode, IList entities, IPropertyContainer entity, Hashtable sqltypes, Hashtable types, bool isReference, ParserValidationDelegate vd)
{
ArrayList fields = new ArrayList();
if (propertiesNode != null)
{
foreach (XmlNode node in propertiesNode.ChildNodes)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
PropertyElement field = BuildElement(node, types, sqltypes, entity, isReference, vd);
//Adds all attributes including all non defined by element class
foreach (XmlAttribute attribute in node.Attributes)
{
if (!field.Attributes.ContainsKey(attribute.Name))
{
field.Attributes.Add(attribute.Name, attribute.Value);
}
}
fields.Add(field);
// Add in any subfields...
if (field.Entity.Name.Length > 0 && !field.UseEntityDao)
{
String subEntityName = node.Attributes["entity"].Value;
EntityElement subentity = EntityElement.FindEntityByName((ArrayList)entities, subEntityName);
// check to see if subentity is self
if (subentity == null && entity.Name == subEntityName)
{
subentity = (EntityElement)entity;
}
if (subentity != null)
{
// Only entity elements have entity atttribute
SqlEntityElement sqlEntity = ((EntityElement)entity).SqlEntity;
String prefix = subentity.Name + "_";
if (node.Attributes["prefix"] != null)
{
prefix = node.Attributes["prefix"].Value;
}
foreach (PropertyElement f in subentity.Fields)
{
PropertyElement subfield = (PropertyElement)f.Clone();
subfield.Name = field.Name + "." + subfield.Name;
// if field has sql column defined
if (!f.Column.Name.Equals(String.Empty))
{
ColumnElement column = sqlEntity.FindColumnByName(prefix + subfield.Column.Name);
if (column != null)
{
subfield.Column = (ColumnElement)column.Clone();
}
else
{
vd(ParserValidationArgs.NewError("column (" + prefix + subfield.Column.Name + ") specified for property (" + subfield.Name + ") on entity (" + entity.Name + ") was not found in sql entity (" + sqlEntity.Name + ")"));
}
}
fields.Add(subfield);
}
}
else
{
vd(ParserValidationArgs.NewError("Entity " + entity.Name + " referenced another entity that was not defined (or defined below this one): " + node.Attributes["entity"].Value));
}
}
}
}
return(fields);
}
public static ArrayList ParseFromXml(Configuration options, XmlDocument doc, Hashtable sqltypes, Hashtable types, ArrayList sqlentities, ParserValidationDelegate vd)
{
ArrayList entities = new ArrayList();
XmlNode entitiesNode = doc.DocumentElement.Cast <XmlNode>().FirstOrDefault(x => x.Name.ToLowerInvariant() == "entities");
if (entitiesNode == null)
{
return(entities);
}
IEnumerable <XmlNode> elements = entitiesNode.ChildNodes.Cast <XmlNode>().Where(x => x.Name.ToLowerInvariant() == "entity");
foreach (XmlNode node in elements)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
EntityElement entity = new EntityElement();
entity.Name = node.Attributes["name"].Value;
if (node.Attributes["namespace"] != null)
{
entity.Namespace = node.Attributes["namespace"].Value;
}
if (node.Attributes["sqlentity"] != null)
{
SqlEntityElement sqlentity = SqlEntityElement.FindByName(sqlentities, node.Attributes["sqlentity"].Value);
if (sqlentity != null)
{
entity.SqlEntity = (SqlEntityElement)sqlentity.Clone();
}
else
{
entity.SqlEntity.Name = node.Attributes["sqlentity"].Value;
vd(ParserValidationArgs.NewError("sqlentity (" + entity.SqlEntity.Name + ") specified in entity " + entity.Name + " could not be found as an defined sql entity"));
}
}
if (node.Attributes["baseentity"] != null)
{
EntityElement baseentity = EntityElement.FindEntityByName(entities, node.Attributes["baseentity"].Value);
if (baseentity != null)
{
entity.BaseEntity = (EntityElement)baseentity.Clone();
}
else
{
entity.BaseEntity.Name = node.Attributes["baseentity"].Value;
vd(ParserValidationArgs.NewError("baseentity (" + entity.BaseEntity.Name + ") specified in entity " + entity.Name + " could not be found as an defined entity (or is defined after this entity in the config file)"));
}
}
if (node.Attributes["abstract"] != null)
{
entity.IsAbstract = Boolean.Parse(node.Attributes["abstract"].Value);
}
if (node.Attributes["namespace"] != null)
{
entity.HasNamespace = !String.IsNullOrEmpty(node.Attributes["namespace"].Value);
}
if (node.Attributes["log"] != null)
{
entity.DoLog = Boolean.Parse(node.Attributes["log"].Value);
}
if (node.Attributes["returnwholeobject"] != null)
{
entity.ReturnWholeObject = Boolean.Parse(node.Attributes["returnwholeobject"].Value);
}
if (node.Attributes["prepareforinsert"] != null)
{
entity.PrepareForInsert = Boolean.Parse(node.Attributes["prepareforinsert"].Value);
}
if (node.Attributes["dependententity"] != null)
{
entity.DependentEntity = Boolean.Parse(node.Attributes["dependententity"].Value);
}
if (node.Attributes["jointable"] != null)
{
entity.JoinTable = Boolean.Parse(node.Attributes["jointable"].Value);
}
XmlNode descriptionNode = node.SelectSingleNode(DESCRIPTION);
if (descriptionNode != null)
{
entity.Description = descriptionNode.InnerText.Trim();
}
//Adds all attributes including all not defined by element class
foreach (XmlAttribute attribute in node.Attributes)
{
if (!entity.Attributes.ContainsKey(attribute.Name))
{
entity.Attributes.Add(attribute.Name, attribute.Value);
}
}
entity.dependents = ParseDependentsFromXml(node, vd);
entity.fields = PropertyElement.ParseFromXml(doc, entities, entity, sqltypes, types, vd);
entity.finders = FinderElement.ParseFromXml(doc, node, entities, entity, sqltypes, types, vd);
entity.comparers = ComparerElement.ParseFromXml(node, entities, entity, sqltypes, types, vd);
entities.Add(entity);
}
StringCollection names = new StringCollection();
foreach (EntityElement entity in entities)
{
if (names.Contains(entity.Name))
{
vd(new ParserValidationArgs(ParserValidationSeverity.ERROR, "duplicate entity definition for " + entity.Name));
}
else
{
names.Add(entity.Name);
}
}
return(entities);
}
public static ArrayList ParseFromXml(XmlNode root, SqlEntityElement sqlentity, Hashtable sqltypes, Hashtable types, ParserValidationDelegate vd)
{
ArrayList columns = new ArrayList();
XmlNodeList elements = null;
foreach (XmlNode n in root.ChildNodes)
{
if (n.Name.Equals("columns"))
{
elements = n.ChildNodes;
break;
}
}
if (elements != null)
{
foreach (XmlNode node in elements)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
if (node.Name.Equals("column"))
{
ColumnElement column = new ColumnElement();
column.Name = GetAttributeValue(node, NAME, String.Empty);
if (column.Name.Equals(String.Empty))
{
vd(ParserValidationArgs.NewError("SqlEntity " + sqlentity.Name + " has a column that a name was not specified or was blank"));
}
column.Description = node.InnerText.Trim();
if (node.Attributes["sqltype"] != null)
{
column.SqlType.Name = node.Attributes["sqltype"].Value;
if (sqltypes.ContainsKey(column.SqlType.Name))
{
column.SqlType = (SqlTypeElement)((SqlTypeElement)sqltypes[column.SqlType.Name]).Clone();
}
else
{
vd(ParserValidationArgs.NewError("SqlType " + column.SqlType.Name + " was not defined [column=" + sqlentity.Name + "." + column.Name + "]"));
}
}
if (node.Attributes["required"] != null)
{
column.Required = Boolean.Parse(node.Attributes["required"].Value);
}
if (node.Attributes["identity"] != null)
{
column.Identity = Boolean.Parse(node.Attributes["identity"].Value);
}
if (node.Attributes["rowguidcol"] != null)
{
column.RowGuidCol = Boolean.Parse(node.Attributes["rowguidcol"].Value);
}
if (node.Attributes["viewcolumn"] != null)
{
column.ViewColumn = Boolean.Parse(node.Attributes["viewcolumn"].Value);
}
if (node.Attributes["increment"] != null)
{
column.Increment = Int32.Parse(node.Attributes["increment"].Value);
}
if (node.Attributes["seed"] != null)
{
column.Seed = Int32.Parse(node.Attributes["seed"].Value);
}
if (node.Attributes["default"] != null)
{
column.Default = node.Attributes["default"].Value;
}
if (node.Attributes["formula"] != null)
{
column.Formula = node.Attributes["formula"].Value;
}
if (node.Attributes["length"] != null)
{
column.SqlType.Length = Int32.Parse(node.Attributes["length"].Value);
}
if (node.Attributes["scale"] != null)
{
column.SqlType.Scale = Int32.Parse(node.Attributes["scale"].Value);
}
if (node.Attributes["precision"] != null)
{
column.SqlType.Precision = Int32.Parse(node.Attributes["precision"].Value);
}
if (node.Attributes["expression"] != null)
{
column.Expression = node.Attributes["expression"].Value;
}
if (node.Attributes["obsolete"] != null)
{
column.Obsolete = Boolean.Parse(node.Attributes[OBSOLETE].Value);
}
if (node.Attributes["retainnonnullvalue"] != null)
{
column.RetainNonNullValue = Boolean.Parse(node.Attributes["retainnonnullvalue"].Value);
}
if (node.Attributes[COLLATE] != null)
{
column.Collate = node.Attributes[COLLATE].Value;
}
//Adds all attributes including all non defined by element class
foreach (XmlAttribute attribute in node.Attributes)
{
if (!column.Attributes.ContainsKey(attribute.Name))
{
column.Attributes.Add(attribute.Name, attribute.Value);
}
}
column.Description = node.InnerText.Trim();
columns.Add(column);
}
}
}
return(columns);
}
public static ArrayList ParseFromXml(XmlNode root, SqlEntityElement sqlentity, Hashtable sqltypes, Hashtable types, ParserValidationDelegate vd)
{
ArrayList constraints = new ArrayList();
XmlNodeList elements = null;
foreach (XmlNode n in root.ChildNodes)
{
if (n.Name.Equals("constraints"))
{
elements = n.ChildNodes;
break;
}
}
if (elements != null)
{
foreach (XmlNode node in elements)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
ConstraintElement constraint = new ConstraintElement();
constraint.Name = node.Attributes["name"].Value;
constraint.Type = node.Attributes["type"].Value;
if (node.Attributes["clustered"] != null)
{
constraint.Clustered = Boolean.Parse(node.Attributes["clustered"].Value);
}
if (node.Attributes["foreignentity"] != null)
{
constraint.ForeignEntity.Name = node.Attributes["foreignentity"].Value;
}
if (node.Attributes["checkclause"] != null)
{
constraint.CheckClause = node.Attributes["checkclause"].Value;
}
if (node.Attributes["checkenum"] != null)
{
constraint.CheckEnum.Name = node.Attributes["checkenum"].Value;
}
foreach (XmlNode n in node.ChildNodes)
{
if (n.NodeType == XmlNodeType.Comment)
{
continue;
}
ColumnElement column = sqlentity.FindColumnByName(n.Attributes["name"].Value);
if (column == null)
{
vd(ParserValidationArgs.NewError("column specified (" + n.Attributes["name"].Value + ") in constraint (" + constraint.Name + ") not found as column."));
column = new ColumnElement();
column.Name = n.Attributes["name"].Value;
}
if (n.Attributes["foreigncolumn"] != null)
{
column.ForeignColumn = n.Attributes["foreigncolumn"].Value;
}
constraint.Columns.Add(column);
}
constraints.Add(constraint);
}
}
return(constraints);
}
public Configuration(XmlNode root, ParserValidationDelegate vd)
{
if (root.HasChildNodes)
{
for (Int32 i = 0; i < root.ChildNodes.Count; i++)
{
XmlNode node = root.ChildNodes[i];
if (node.Name.Equals("setting"))
{
switch (node.Attributes["name"].Value.ToLower())
{
case "rootnamespace":
this.rootNameSpace = node.Attributes["value"].Value;
break;
case "rootdirectory":
this.rootDirectory = node.Attributes["value"].Value;
break;
case "typesclassdirectory":
this.typesClassDirectory = node.Attributes["value"].Value;
break;
case "daoclassdirectory":
this.daoClassDirectory = node.Attributes["value"].Value;
break;
case "doclassdirectory":
this.doClassDirectory = node.Attributes["value"].Value;
break;
case "collectionclassdirectory":
this.collectionClassDirectory = node.Attributes["value"].Value;
break;
case "generatedataobjectclasses":
this.generateDataObjectClasses = Boolean.Parse(node.Attributes["value"].Value);
break;
case "dataobjectbaseclass":
this.dataObjectBaseClass = node.Attributes["value"].Value;
break;
case "daobaseclass":
this.daoBaseClass = node.Attributes["value"].Value;
break;
case "enumbaseclass":
this.enumBaseClass = node.Attributes["value"].Value;
break;
case "testclassdirectory":
this.testClassDirectory = node.Attributes["value"].Value;
break;
default:
vd(ParserValidationArgs.NewWarning("Unrecognized configuration option: " + node.Attributes["name"].Value + " = " + node.Attributes["value"].Value));
break;
}
}
}
}
}
/// <summary>
/// Validates that names are unique across property references and computed properties.
/// </summary>
/// <param name="vd">Validation delegate for error reporting.</param>
private void ValidateUniqueNames(ParserValidationDelegate vd)
{
ArrayList names = new ArrayList();
foreach (EntityReferenceElement e in EntityReferences)
{
foreach (PropertyElement p in e.PropertyReferences)
{
names.Add(p.GetSqlAlias());
}
}
foreach (PropertyElement p in ComputedProperties)
{
names.Add(p.Name);
}
names.Sort();
string prevName = String.Empty;
int errorCount = 1;
for (int i = 0; i < names.Count; i++)
{
string name = (string)(names[i]);
if (name == prevName)
{
errorCount++;
}
if (errorCount > 1 && (name != prevName || i >= names.Count - 1))
{
vd(ParserValidationArgs.NewError("The property name " + prevName + " occurs " + errorCount.ToString() + " times in the report extraction " + this.Name));
errorCount = 1;
}
prevName = name;
}
names = new ArrayList();
foreach (EntityReferenceElement e in EntityReferences)
{
names.Add(e.Name);
}
names.Sort();
prevName = String.Empty;
errorCount = 1;
for (int i = 0; i < names.Count; i++)
{
string name = (string)(names[i]);
if (name == prevName)
{
errorCount++;
}
if (errorCount > 1 && (name != prevName || i >= names.Count - 1))
{
vd(ParserValidationArgs.NewError("The entity reference name " + prevName + " occurs " + errorCount.ToString() + " times in the report extraction " + this.Name));
errorCount = 1;
}
prevName = name;
}
}
public static ArrayList ParseFromXml(XmlNode root, SqlEntityElement sqlentity, Hashtable sqltypes, Hashtable types, ParserValidationDelegate vd)
{
ArrayList indexes = new ArrayList();
XmlNodeList elements = null;
foreach (XmlNode n in root.ChildNodes)
{
if (n.Name.Equals("indexes"))
{
elements = n.ChildNodes;
break;
}
}
if (elements != null)
{
foreach (XmlNode node in elements)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
IndexElement index = new IndexElement();
index.Name = node.Attributes["name"].Value;
if (node.Attributes["clustered"] != null)
{
index.Clustered = Boolean.Parse(node.Attributes["clustered"].Value);
}
if (node.Attributes["unique"] != null)
{
index.Unique = Boolean.Parse(node.Attributes["unique"].Value);
}
foreach (XmlNode n in node.ChildNodes)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
if (n.Name == "include")
{
foreach (XmlNode includeNode in n.ChildNodes)
{
ColumnElement includeColumn = sqlentity.FindColumnByName(includeNode.Attributes["name"].Value);
if (includeColumn == null)
{
vd(ParserValidationArgs.NewError("column specified (" + includeNode.Attributes["name"].Value + ") in index (" + index.Name + ") not found as column."));
includeColumn = new ColumnElement();
includeColumn.Name = includeNode.Attributes["name"].Value;
}
index.IncludeColumns.Add(includeColumn);
}
continue;
}
ColumnElement column = sqlentity.FindColumnByName(n.Attributes["name"].Value);
if (column == null)
{
vd(ParserValidationArgs.NewError("column specified (" + n.Attributes["name"].Value + ") in index (" + index.Name + ") not found as column."));
column = new ColumnElement();
column.Name = n.Attributes["name"].Value;
}
if (n.Attributes["sortdirection"] != null)
{
column.SortDirection = n.Attributes["sortdirection"].Value;
}
index.Columns.Add(column);
}
indexes.Add(index);
}
}
return(indexes);
}
public static ArrayList ParseFromXml(XmlNode root, DatabaseElement database, SqlEntityElement sqlentity, Hashtable sqltypes, Hashtable types, ParserValidationDelegate vd)
{
ArrayList list = new ArrayList();
XmlNodeList elements = root.SelectNodes("views/view");
if (elements != null)
{
foreach (XmlNode node in elements)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
ViewElement view = new ViewElement();
view.Name = ParseStringAttribute(node, "name", String.Empty);
foreach (XmlNode n in node.ChildNodes)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
ConstraintElement constraint = sqlentity.FindConstraintByName(n.Attributes["name"].Value);
if (constraint == null)
{
vd(ParserValidationArgs.NewError("constraint specified (" + n.Attributes["name"].Value + ") in view (" + view.Name + ") not found."));
constraint = new ConstraintElement();
constraint.Name = n.Attributes["name"].Value;
}
else
{
if (!constraint.Type.Equals(ConstraintElement.FOREIGN_KEY))
{
vd(ParserValidationArgs.NewError("View [" + view.Name + "] references a constraint that is not a foreign key constraint: " + constraint.Name));
}
}
constraint.Prefix = ParseStringAttribute(n, "prefix", constraint.ForeignEntity.Name + "_");
SqlEntityElement foreignEntity = database.FindSqlEntityByName(constraint.ForeignEntity.Name);
// check to see if the foreignEntity is itself
if (foreignEntity == null && sqlentity.Name == constraint.ForeignEntity.Name)
{
foreignEntity = sqlentity;
}
if (foreignEntity == null)
{
vd(ParserValidationArgs.NewError("View [" + view.Name + "] references a constraint that references an sql entity that was not defined (or was not defined before this sql entity): " + constraint.ForeignEntity));
}
else
{
ArrayList columnsToAdd = new ArrayList();
foreach (ColumnElement column in foreignEntity.Columns)
{
ColumnElement viewColumn = (ColumnElement)column.Clone();
if (!constraint.Prefix.Equals(String.Empty))
{
viewColumn.Name = constraint.Prefix + viewColumn.Name;
}
viewColumn.Prefix = constraint.Prefix;
viewColumn.ForeignSqlEntity = constraint.ForeignEntity.Name;
viewColumn.ViewColumn = true;
columnsToAdd.Add(viewColumn);
}
sqlentity.Columns.AddRange(columnsToAdd);
}
view.Constraints.Add(constraint);
}
// validation
if (view.Name.Equals(String.Empty))
{
vd(ParserValidationArgs.NewError("View does not have a name: " + Environment.NewLine + node.OuterXml));
}
list.Add(view);
}
}
return(list);
}
public static Hashtable ParseFromXml(Configuration options, XmlNode doc, ParserValidationDelegate vd)
{
Hashtable types = new Hashtable();
XmlNodeList nodes = doc.SelectNodes("DataTierGenerator/types/type");
foreach (XmlNode node in nodes)
{
if (node.NodeType == XmlNodeType.Comment)
{
continue;
}
TypeElement type = new TypeElement();
type.Name = node.Attributes["name"].Value;
type.ConcreteType = type.Name;
if (node.Attributes["concretetype"] != null)
{
type.ConcreteType = node.Attributes["concretetype"].Value;
}
if (node.Attributes["namespace"] != null)
{
type.Package = node.Attributes["namespace"].Value;
}
if (node.Attributes["newinstanceformat"] != null)
{
type.NewInstanceFormat = node.Attributes["newinstanceformat"].Value;
type.NullInstanceFormat = type.NewInstanceFormat;
}
if (node.Attributes["nullinstanceformat"] != null)
{
type.NullInstanceFormat = node.Attributes["nullinstanceformat"].Value;
}
if (node.Attributes["converttosqltypeformat"] != null)
{
type.ConvertToSqlTypeFormat = node.Attributes["converttosqltypeformat"].Value;
}
if (node.Attributes["convertfromsqltypeformat"] != null)
{
type.ConvertFromSqlTypeFormat = node.Attributes["convertfromsqltypeformat"].Value;
}
if (node.Attributes[CONVERT_FOR_COMPARE] != null)
{
type.ConvertForCompare = node.Attributes[CONVERT_FOR_COMPARE].Value;
}
if (types.ContainsKey(type.Name))
{
vd(ParserValidationArgs.NewWarning("ignoring duplicate definition of type: " + type.Name));
}
else
{
types.Add(type.Name, type);
}
}
// // add entities as data objects to types if not already defined
// elements = doc.DocumentElement.GetElementsByTagName("entity");
// foreach (XmlNode node in elements) {
// if (node.NodeType == XmlNodeType.Comment) {
// continue;
// }
// if (!types.Contains(node.Attributes["name"].Value + "Data")) {
// TypeElement type = new TypeElement();
// type.Name = node.Attributes["name"].Value + "Data";
// type.ConcreteType = type.Name;
// type.Package = options.GetDONameSpace("");
// type.NewInstanceFormat = "new " + type.Name + "()";
// types.Add(type.Name, type);
// }
//
// // TODO: needs review, hacked for Dave
// // add interfaces - use new x() for empty instance constructor
// if (!types.Contains("I" + node.Attributes["name"].Value)) {
// TypeElement type = new TypeElement();
// type.Name = "I" + node.Attributes["name"].Value;
// type.ConcreteType = type.Name;
// type.Package = options.GetDONameSpace("");
// type.NewInstanceFormat = "new " + node.Attributes["name"].Value + "()";
// types.Add(type.Name, type);
// }
//
// // TODO: needs review, hacked for Dave
// // add business entities - use new x() for empty instance constructor
// if (!types.Contains(node.Attributes["name"].Value)) {
// TypeElement type = new TypeElement();
// type.Name = node.Attributes["name"].Value;
// type.ConcreteType = type.Name;
// type.Package = options.GetBusinessLogicNameSpace();
// type.NewInstanceFormat = "new " + type.Name + "()";
// types.Add(type.Name, type);
// }
// }
//
//
// // add enums to types if not already defined
// elements = doc.DocumentElement.GetElementsByTagName("enum");
// foreach (XmlNode node in elements) {
// if (node.NodeType == XmlNodeType.Comment) {
// continue;
// }
// if (!types.Contains(node.Attributes["name"].Value)) {
// TypeElement type = new TypeElement();
// type.Name = node.Attributes["name"].Value;
// type.ConcreteType = type.Name;
// type.Package = options.GetTypeNameSpace("");
// type.ConvertToSqlTypeFormat = "{1}.DBValue";
// type.ConvertFromSqlTypeFormat = type.Name + ".GetInstance({2})";
// type.NewInstanceFormat = type.Name + ".DEFAULT";
// type.NullInstanceFormat = type.Name + ".UNSET";
// types.Add(type.Name, type);
// }
// }
//
// // see if we want to generate collections for all entities
// XmlNodeList collectionElement = doc.DocumentElement.GetElementsByTagName ("collections");
// XmlNode collectionNode = collectionElement[0];
// Boolean generateAll = false;
// if (collectionNode.Attributes["generateall"] != null) {
// generateAll = Boolean.Parse (collectionNode.Attributes["generateall"].Value.ToString ());
// }
//
// if (generateAll) {
// // add collections for all entities as data objects to types if not already defined
// elements = doc.DocumentElement.GetElementsByTagName ("entity");
// foreach (XmlNode node in elements) {
// if (node.NodeType == XmlNodeType.Comment) {
// continue;
// }
// if (!types.Contains (node.Attributes["name"].Value + "List")) {
// TypeElement type = new TypeElement ();
// type.Name = node.Attributes["name"].Value + "List";
// type.ConcreteType = type.Name;
// type.Package = options.GetDONameSpace ("");
// type.NewInstanceFormat = type.Name + ".DEFAULT";
// type.NullInstanceFormat = type.Name + ".UNSET";
// types.Add (type.Name, type);
// }
// }
// } else {
// // add collections as data objects to types if not already defined
// elements = doc.DocumentElement.GetElementsByTagName("collection");
// foreach (XmlNode node in elements) {
// if (node.NodeType == XmlNodeType.Comment) {
// continue;
// }
// if (!types.Contains(node.Attributes["name"].Value)) {
// TypeElement type = new TypeElement();
// type.Name = node.Attributes["name"].Value;
// type.ConcreteType = type.Name;
// type.Package = options.GetDONameSpace("");
// //type.NewInstanceFormat = "new " + type.Name + "()";
// type.NewInstanceFormat = type.Name + ".DEFAULT";
// type.NullInstanceFormat = type.Name + ".UNSET";
// types.Add(type.Name, type);
// }
// }
// }
return(types);
}
