private void GenerateGetReferencesMethod(CodeTypeDeclaration file, EAPClass classPom)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.Name = "GetReferences";
method.ReturnType = new CodeTypeReference(typeof(void));
method.Parameters.Add(new CodeParameterDeclarationExpression("Dictionary<ModelCode, List<long>>", "references"));
method.Parameters.Add(new CodeParameterDeclarationExpression("TypeOfReference", "refType"));
foreach (EAPAttribute att in classPom.Attributes)
{
if (att.IsListOfReferences == true)
{
CodeConditionStatement codeIf = new CodeConditionStatement(new
CodeSnippetExpression(att.Name + " != null && " + att.Name + ".Count > 0 && (refType == TypeOfReference.Target || refType == TypeOfReference.Both)"), new
CodeSnippetStatement("\t\t\t\treferences[ModelCode." + att.Code + "] = " + att.Name + ".GetRange(0, " + att.Name + ".Count);"));
method.Statements.Add(codeIf);
}
else if (att.IsReference == true)
{
CodeStatement[] listTrueStatement = new CodeStatement[]
{
new CodeSnippetStatement("\t\t\t\treferences[ModelCode." + att.Code + "] = new List<long>();"),
new CodeSnippetStatement("\t\t\t\treferences[ModelCode." + att.Code + "].Add(" + att.Name + ");")
};
CodeConditionStatement codeIf = new CodeConditionStatement(new
CodeSnippetExpression(att.Name + " != 0 && (refType == TypeOfReference.Reference || refType == TypeOfReference.Both)"), listTrueStatement);
method.Statements.Add(codeIf);
}
}
method.Statements.Add(new CodeSnippetStatement("\t\t\tbase.GetReferences(references, refType);"));
file.Members.Add(method);
}
public void FixGroupClass()
{
foreach (EAPModel model in eapModels.Models)
{
foreach (KeyValuePair <string, string> nameClass in model.GroupClasNames)
{
if (model.Classes.ContainsKey(nameClass.Key))
{
EAPClass eapClass = (EAPClass)model.Classes[nameClass.Key];
if (model.Classes.ContainsKey(nameClass.Value))
{
EAPClass eapClassParent = (EAPClass)model.Classes[nameClass.Value];
eapClassParent.Attributes.AddRange(eapClass.Attributes);
eapClass.Attributes.Clear();
}
else
{
if (Validate)
{
tw.WriteLine("Model Code for class: {0},", eapClass.Code);
tw.WriteLine("Name for class: {0},", eapClass.Name);
tw.WriteLine("Name for class Parent: {0},", nameClass.Value);
tw.WriteLine("Parent class name:" + nameClass.Value + ", does not exist in Eap.");
tw.WriteLine("*************************************************************************");
tw.WriteLine("\n\n");
}
}
}
}
}
}
private CodeCompileUnit BuildCodeCUnit(EAPModel model, object v, bool flagDb)
{
CodeCompileUnit unit = null;
EAPClass classPom = (EAPClass)v;
unit = CreateClass(model, classPom, flagDb);
return(unit);
}
private void GenerateHashCodeMethod(CodeTypeDeclaration file, EAPClass classPom)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.Name = "GetHashCode";
method.ReturnType = new CodeTypeReference(typeof(int));
method.Statements.Add(new CodeMethodReturnStatement(new CodeArgumentReferenceExpression("base.GetHashCode()")));
file.Members.Add(method);
}
private void GenerateSetPropertyMethod(CodeTypeDeclaration file, EAPClass classPom)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.Name = "SetProperty";
method.ReturnType = new CodeTypeReference(typeof(void));
method.Parameters.Add(new CodeParameterDeclarationExpression("Property", "property"));
List <CodeSnippetStatement> snipets = new List <CodeSnippetStatement>()
{
new CodeSnippetStatement("\t\t\t\tswitch(property.Id)"), new CodeSnippetStatement("\t\t\t\t{")
};
foreach (EAPAttribute att in classPom.Attributes)
{
if (att.IsListOfReferences == true)
{
continue;
}
CodeSnippetStatement css = new CodeSnippetStatement("\t\t\t\t\tcase ModelCode." + att.Code + ":");
CodeSnippetStatement cssProp = new CodeSnippetStatement();
if (att.TypeCode != "" && att.TypeCode.Equals("Enum"))
{
cssProp = new CodeSnippetStatement("\t\t\t\t\t\t" + att.Name + " = (" + att.MeasurementType + ") property.AsEnum();");
}
else if (att.IsReference == true || att.TypeCode.Equals("Class"))
{
cssProp = new CodeSnippetStatement("\t\t\t\t\t\t" + att.Name + " = property.AsReference();");
}
else
{
cssProp = new CodeSnippetStatement("\t\t\t\t\t\t" + att.Name + " = property." + StringManipulationManager.GetAsMethod(att.MeasurementType));
}
CodeSnippetStatement cssBreak = new CodeSnippetStatement("\t\t\t\t\t\tbreak;");
snipets.Add(css); snipets.Add(cssProp); snipets.Add(cssBreak);
}
CodeSnippetStatement cssDefault = new CodeSnippetStatement("\t\t\t\t\tdefault:");
CodeSnippetStatement cssBase = new CodeSnippetStatement("\t\t\t\t\t\tbase.SetProperty(property);");
CodeSnippetStatement cssBreakDefault = new CodeSnippetStatement("\t\t\t\t\t\tbreak;");
CodeSnippetStatement ccss = new CodeSnippetStatement("\t\t\t\t}");
snipets.Add(cssDefault); snipets.Add(cssBase); snipets.Add(cssBreakDefault); snipets.Add(ccss);
foreach (var item in snipets)
{
method.Statements.Add(item);
}
file.Members.Add(method);
}
private void GenerateRemoveReferencMethod(CodeTypeDeclaration file, EAPClass classPom)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.Name = "RemoveReference";
method.ReturnType = new CodeTypeReference(typeof(void));
method.Parameters.Add(new CodeParameterDeclarationExpression("ModelCode", "referenceId"));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(long), "globalId"));
CodeSnippetStatement switctS = new CodeSnippetStatement("\t\t\t\tswitch(referenceId)");
CodeSnippetStatement bracket = new CodeSnippetStatement("\t\t\t\t{");
method.Statements.Add(switctS); method.Statements.Add(bracket);
foreach (EAPAttribute att in classPom.Attributes)
{
if (att.IsListOfReferences == true)
{
CodeSnippetStatement mc = new CodeSnippetStatement("\t\t\t\t\tcase ModelCode." + att.onSameConnectorPairAtt.Code + ":");
CodeSnippetStatement ifSt = new CodeSnippetStatement("\t\t\t\t\t\tif (" + att.Name + ".Contains(globalId))");
CodeSnippetStatement openBr = new CodeSnippetStatement("\t\t\t\t\t\t{");
CodeStatement trueStatement = new CodeSnippetStatement("\t\t\t\t\t\t\t" + att.Name + ".Remove(globalId);");
CodeSnippetStatement closeBrec = new CodeSnippetStatement("\t\t\t\t\t\t}");
CodeSnippetStatement elseSt = new CodeSnippetStatement("\t\t\t\t\t\telse");
CodeSnippetStatement openBrElse = new CodeSnippetStatement("\t\t\t\t\t\t{");
CodeStatement falseStatement = new CodeSnippetStatement("\t\t\t\t\t\t\tCommonTrace.WriteTrace(CommonTrace.TraceWarning, \"Entity(GID = 0x{ 0:x16}) doesn't contain reference 0x{1:x16}.\", this.GlobalId, globalId);");
CodeSnippetStatement closeBrecElse = new CodeSnippetStatement("\t\t\t\t\t\t}");
CodeSnippetStatement breakSnipet = new CodeSnippetStatement("\t\t\t\t\t\tbreak;");
method.Statements.Add(mc); method.Statements.Add(ifSt); method.Statements.Add(openBr);
method.Statements.Add(trueStatement); method.Statements.Add(closeBrec); method.Statements.Add(elseSt);
method.Statements.Add(openBrElse); method.Statements.Add(falseStatement); method.Statements.Add(closeBrecElse); method.Statements.Add(breakSnipet);
}
}
CodeSnippetStatement defaultS = new CodeSnippetStatement("\t\t\t\t\tdefault:");
CodeSnippetStatement baseS = new CodeSnippetStatement("\t\t\t\t\t\t base.RemoveReference(referenceId, globalId);");
CodeSnippetStatement breakS = new CodeSnippetStatement("\t\t\t\t\t\tbreak;");
CodeSnippetStatement ccss = new CodeSnippetStatement("\t\t\t\t}");
method.Statements.Add(defaultS); method.Statements.Add(baseS); method.Statements.Add(breakS); method.Statements.Add(ccss);
file.Members.Add(method);
}
public void FindType(EAPClass l_Class, EAPAttribute l_MyAttr, EA.Attribute l_Attr)
{
//PropertyType type = 0;
if ((l_MyAttr.Code != null && l_MyAttr.Code != "") || true)
{
if (Enum.IsDefined(typeof(MeasurementType), l_Attr.Type.ToUpper()))
{
l_MyAttr.MeasurementType = l_Attr.Type;
}
else
{
List <string> typeStr = new List <string>()
{
"bool", "int", "long", "string", "short", "double", "float",
"byte", "modelcode", "lid", "gid"
};
if (l_Attr.Type.Split('<').Length > 1)
{
string helpString = l_Attr.Type.Remove(0, (l_Attr.Type.IndexOf('<') + 1));
// l_MyAttr.MeasurementType = helpString.Remove(helpString.IndexOf('>'));
l_MyAttr.MeasurementType = l_Attr.Type;
if (Enum.IsDefined(typeof(MeasurementType), helpString.Remove(helpString.IndexOf('>'))))
{
l_MyAttr.MeasurementType = helpString.Remove(helpString.IndexOf('>'));
}
else
{
l_MyAttr.MeasurementType = l_Attr.Type;
}
}
else
{
if (!typeStr.Contains(l_Attr.Type.ToLower()))
{
l_MyAttr.MeasurementType = l_Attr.Type;
}
else if (typeStr.Contains(l_Attr.Type.ToLower()))
{
//GenerateUIControlsBasedOnPropType(l_Attr.Type.ToLower(), l_MyAttr, false);
}
}
}
}
}
private void GenerateHasPropertyMethod(CodeTypeDeclaration file, EAPClass classPom)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.Name = "HasProperty";
method.ReturnType = new CodeTypeReference(typeof(bool));
method.Parameters.Add(new CodeParameterDeclarationExpression("ModelCode", "t"));
List <CodeSnippetStatement> snipets = new List <CodeSnippetStatement>()
{
new CodeSnippetStatement("\t\t\t\tswitch(t)"), new CodeSnippetStatement("\t\t\t\t{")
};
foreach (EAPAttribute att in classPom.Attributes)
{
CodeSnippetStatement css = new CodeSnippetStatement("\t\t\t\t\tcase ModelCode." + att.Code + ":");
snipets.Add(css);
}
if (classPom.Attributes.Count > 0)
{
CodeSnippetStatement cssReturnT = new CodeSnippetStatement("\t\t\t\t\t\treturn true;");
CodeSnippetStatement cssDefault = new CodeSnippetStatement("\t\t\t\t\tdefault:");
CodeSnippetStatement cssReturnBase = new CodeSnippetStatement("\t\t\t\t\t\treturn base.HasProperty(t);");
CodeSnippetStatement ccss = new CodeSnippetStatement("\t\t\t\t}");
snipets.Add(cssReturnT); snipets.Add(cssDefault); snipets.Add(cssReturnBase); snipets.Add(ccss);
}
else
{
CodeSnippetStatement cssDefault = new CodeSnippetStatement("\t\t\t\t\tdefault:");
CodeSnippetStatement cssReturnBase = new CodeSnippetStatement("\t\t\t\t\t\treturn base.HasProperty(t);");
CodeSnippetStatement ccss = new CodeSnippetStatement("\t\t\t\t}");
snipets.Add(cssDefault); snipets.Add(cssReturnBase); snipets.Add(ccss);
}
foreach (var item in snipets)
{
method.Statements.Add(item);
}
file.Members.Add(method);
}
private void GenerateGetProperty(CodeTypeDeclaration file, EAPClass classPom)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.Name = "GetProperty";
method.ReturnType = new CodeTypeReference(typeof(void));
method.Parameters.Add(new CodeParameterDeclarationExpression("Property", "property"));
List <CodeSnippetStatement> snipets = new List <CodeSnippetStatement>()
{
new CodeSnippetStatement("\t\t\t\tswitch(property.Id)"), new CodeSnippetStatement("\t\t\t\t{")
};
foreach (EAPAttribute att in classPom.Attributes)
{
CodeSnippetStatement css = new CodeSnippetStatement("\t\t\t\t\tcase ModelCode." + att.Code + ":");
CodeSnippetStatement cssProp = new CodeSnippetStatement();
if (att.TypeCode != "" && (att.TypeCode.Equals("Enum")))
{
cssProp = new CodeSnippetStatement("\t\t\t\t\t\tproperty.SetValue((short)" + att.Name + ");");
}
else
{
cssProp = new CodeSnippetStatement("\t\t\t\t\t\tproperty.SetValue(" + att.Name + ");");
}
CodeSnippetStatement cssBreak = new CodeSnippetStatement("\t\t\t\t\t\tbreak;");
snipets.Add(css); snipets.Add(cssProp); snipets.Add(cssBreak);
}
CodeSnippetStatement cssDefault = new CodeSnippetStatement("\t\t\t\t\tdefault:");
CodeSnippetStatement cssBase = new CodeSnippetStatement("\t\t\t\t\t\tbase.GetProperty(property);");
CodeSnippetStatement cssBreakDefault = new CodeSnippetStatement("\t\t\t\t\t\tbreak;");
CodeSnippetStatement ccss = new CodeSnippetStatement("\t\t\t\t}");
snipets.Add(cssDefault); snipets.Add(cssBase); snipets.Add(cssBreakDefault); snipets.Add(ccss);
foreach (var item in snipets)
{
method.Statements.Add(item);
}
file.Members.Add(method);
}
public void AddAttributesInClass(EAPModel model, EA.Element p_Elem, EAPClass l_Class, bool group, EAPClass l_ClassGroup = null)
{
if (p_Elem.Attributes.Count != 0)
{
foreach (EA.Attribute l_Attr in p_Elem.Attributes)
{
CollectAttribute(model, l_Attr, l_Class, group, l_ClassGroup);
}
}
if (p_Elem.Connectors.Count != 0)
{
foreach (EA.Connector l_Attr in p_Elem.Connectors)
{
if (l_Attr.Type.Equals("Aggregation") || l_Attr.Type.Equals("Composition") || l_Attr.Type.Equals("Association"))
{
CollenctConectors(model, l_Attr, l_Class, group, p_Elem);
}
}
}
}
private void GenerateIsReferencedProperty(CodeTypeDeclaration file, EAPClass classPom)
{
CodeMemberProperty prop = new CodeMemberProperty();
prop.Attributes = MemberAttributes.Public | MemberAttributes.Override;
prop.Type = new CodeTypeReference(typeof(bool));
prop.Name = "IsReferenced";
prop.HasGet = true;
prop.GetStatements.Add(new CodeSnippetStatement("\t\t\t\t\treturn"));
for (int i = 0; i < classPom.Attributes.Count; i++)
{
if (classPom.Attributes.ElementAt(i).IsListOfReferences == true)
{
CodeSnippetStatement cs = new CodeSnippetStatement("\t\t\t\t\t\t (" + classPom.Attributes.ElementAt(i).Name + ".Count > 0) ||");
prop.GetStatements.Add(cs);
}
}
prop.GetStatements.Add(new CodeSnippetExpression("\tbase.IsReferenced"));
file.Members.Add(prop);
}
public void FindAttributeEnumCode()
{
foreach (EAPModel model in eapModels.Models)
{
foreach (DictionaryEntry l_Entry in model.Classes)
{
EAPClass eapClass = (EAPClass)l_Entry.Value;
for (int i = 0; i < eapClass.Attributes.Count; i++)
{
if (eapClass.Attributes[i].TypeCode != null)
{
if (model.Enums.ContainsKey(eapClass.Attributes[i].TypeCode))
{
eapClass.Attributes[i].TypeCode = model.Enums[eapClass.Attributes[i].TypeCode].Code;
}
else
{
if (Validate)
{
tw.WriteLine("Model Code for class: {0},", eapClass.Code);
tw.WriteLine("Name for class: {0},", eapClass.Name);
tw.WriteLine("Name for attribute: {0},", eapClass.Attributes[i].Name);
tw.WriteLine("Model Code for attribute: {0},", eapClass.Attributes[i].Code);
tw.WriteLine("enum name for attribute: {0},\n", eapClass.Attributes[i].TypeCode);
tw.WriteLine(eapClass.Attributes[i].TypeCode + " enum Name does not exist in Eap.");
tw.WriteLine("*************************************************************************");
tw.WriteLine("\n\n");
}
}
}
}
}
}
}
private void GenerateAddreferenceMethod(CodeTypeDeclaration file, EAPClass classPom)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.Name = "AddReference";
method.ReturnType = new CodeTypeReference(typeof(void));
method.Parameters.Add(new CodeParameterDeclarationExpression("ModelCode", "referenceId"));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(long), "globalId"));
CodeSnippetStatement switctS = new CodeSnippetStatement("\t\t\t\tswitch(referenceId)");
CodeSnippetStatement bracket = new CodeSnippetStatement("\t\t\t\t{");
method.Statements.Add(switctS); method.Statements.Add(bracket);
foreach (EAPAttribute att in classPom.Attributes)
{
if (att.IsListOfReferences == true)
{
CodeSnippetStatement mc = new CodeSnippetStatement("\t\t\t\t\tcase ModelCode." + att.onSameConnectorPairAtt.Code + ":");
CodeSnippetStatement add = new CodeSnippetStatement("\t\t\t\t\t\t" + att.Name + ".Add(globalId);");
CodeSnippetStatement breakSnipet = new CodeSnippetStatement("\t\t\t\t\t\tbreak;");
method.Statements.Add(mc); method.Statements.Add(add); method.Statements.Add(breakSnipet);
}
}
CodeSnippetStatement defaultS = new CodeSnippetStatement("\t\t\t\t\tdefault:");
CodeSnippetStatement baseS = new CodeSnippetStatement("\t\t\t\t\t\t base.AddReference(referenceId, globalId);");
CodeSnippetStatement breakS = new CodeSnippetStatement("\t\t\t\t\t\tbreak;");
CodeSnippetStatement ccss = new CodeSnippetStatement("\t\t\t\t}");
method.Statements.Add(defaultS); method.Statements.Add(baseS); method.Statements.Add(breakS); method.Statements.Add(ccss);
file.Members.Add(method);
}
public void CollectAttribute(EAPModel model, EA.Attribute l_Attr, EAPClass l_Class, bool group, EAPClass l_ClassGroup = null)
{
EAPAttribute l_MyAttr = new EAPAttribute();
l_MyAttr.Description = l_Attr.Notes;
l_MyAttr.Settable = !l_Attr.IsConst;
l_MyAttr.Max = l_Attr.UpperBound;
l_MyAttr.Min = l_Attr.LowerBound;
l_MyAttr.Index = l_Attr.Pos;
l_MyAttr.Default = ReturnValue(l_MyAttr, l_Attr);
l_MyAttr.Visible = !l_Attr.IsStatic;
if (model.Enums.ContainsKey(l_Attr.Type))
{
l_MyAttr.TypeCode = "Enum";
}
if (model.Classes.ContainsKey(l_Attr.Type))
{
l_MyAttr.TypeCode = "Class";
}
if (group)
{
if (l_ClassGroup == null)
{
l_MyAttr.Group = l_Class.Code;
}
else
{
l_MyAttr.Group = l_ClassGroup.Code;
}
}
if (l_MyAttr.Description.Split(':').Length > 1)
{
l_MyAttr.Title = l_MyAttr.Description.Split(':')[0];
l_MyAttr.Description = l_MyAttr.Description.Remove(0, l_MyAttr.Title.Length + 1);
}
else
{
l_MyAttr.Title = "";
l_MyAttr.Description = l_MyAttr.Description.Trim();
}
l_MyAttr.Title = l_MyAttr.Title.Replace("<b>", "").Replace("</b>", "").Replace("<i>", "").Replace("</i>", "").Trim();
l_MyAttr.Description = l_MyAttr.Description.Replace("<b>", "").Replace("</b>", "").Replace("<i>", "").Replace("</i>", "").Trim();
l_MyAttr.Code = l_Attr.Style;
l_MyAttr.Name = l_Attr.Name;
FindType(l_Class, l_MyAttr, l_Attr);
l_MyAttr.Aggregated = GetAggregated(l_Attr, l_MyAttr);
l_MyAttr.Searchable = GetSearchable(l_Attr, l_MyAttr);
l_MyAttr.Cardinality = GetCardinality(l_Attr, l_MyAttr) == 0 ? null : GetCardinality(l_Attr, l_MyAttr).ToString();
if (!(l_Class.AddAttribute(l_MyAttr)))
{
if (Validate)
{
tw.WriteLine("Attribute Model Code:" + l_Attr.Style + ", already exists in Class name: " + l_Class.Name + ". (Look at EAP)");
tw.WriteLine("*************************************************************************");
tw.WriteLine("\n\n");
}
}
}
private void CollenctConectors(EAPModel model, Connector l_Attr, EAPClass l_Class, bool group, EA.Element l_class)
{
EAPAttribute l_MyAttr = new EAPAttribute();
l_MyAttr.Description = l_Attr.Notes;
if (l_MyAttr.Description.Split(':').Length > 1)
{
l_MyAttr.Title = l_MyAttr.Description.Split(':')[0];
l_MyAttr.Description = l_MyAttr.Description.Remove(0, l_MyAttr.Title.Length + 1);
}
else
{
l_MyAttr.Title = "";
l_MyAttr.Description = l_MyAttr.Description.Trim();
}
l_MyAttr.Title = l_MyAttr.Title.Replace("<b>", "").Replace("</b>", "").Replace("<i>", "").Replace("</i>", "").Trim();
l_MyAttr.Description = l_MyAttr.Description.Replace("<b>", "").Replace("</b>", "").Replace("<i>", "").Replace("</i>", "").Trim();
l_MyAttr.Code = l_Attr.Alias;
bool pom = false;
if (l_class.ElementID == l_Attr.ClientID)
{
l_MyAttr.Name = l_Attr.SupplierEnd.Role;
l_MyAttr.Code = l_Attr.SupplierEnd.Alias;
if (StringManipulationManager.GetMaxCardinality(l_Attr.SupplierEnd.Cardinality).Equals("*"))
{
l_MyAttr.Max = "*";
string min = l_Attr.SupplierEnd.Cardinality.Substring(0, 1);
l_MyAttr.Min = min;
// pair of attributes on same connector for Add and Remove Ref
l_MyAttr.onSameConnectorPairAtt = new EAPAttribute(l_Attr.ClientEnd.Role, l_Attr.ClientEnd.Alias);
}
else if (StringManipulationManager.GetMaxCardinality(l_Attr.SupplierEnd.Cardinality).Equals("1"))
{
l_MyAttr.Max = "1";
l_MyAttr.Min = "1";
// pair of attributes on same connector for Add and Remove Ref
l_MyAttr.onSameConnectorPairAtt = new EAPAttribute(l_Attr.ClientEnd.Role, l_Attr.ClientEnd.Alias);
}
else if (StringManipulationManager.GetMaxCardinality(l_Attr.ClientEnd.Cardinality).Equals("2"))
{
l_MyAttr.Max = "2";
l_MyAttr.Min = "0";
// pair of attributes on same connector for Add and Remove Ref
l_MyAttr.onSameConnectorPairAtt = new EAPAttribute(l_Attr.ClientEnd.Role, l_Attr.ClientEnd.Alias);
}
pom = true;
}
else
{
l_MyAttr.Name = l_Attr.ClientEnd.Role;
l_MyAttr.Code = l_Attr.ClientEnd.Alias;
if (StringManipulationManager.GetMaxCardinality(l_Attr.ClientEnd.Cardinality).Equals("*"))
{
l_MyAttr.Max = "*";
string min = l_Attr.ClientEnd.Cardinality.Substring(0, 1);
l_MyAttr.Min = min;
// pair of attributes on same connector for Add and Remove Ref
l_MyAttr.onSameConnectorPairAtt = new EAPAttribute(l_Attr.SupplierEnd.Role, l_Attr.SupplierEnd.Alias);
}
else if (StringManipulationManager.GetMaxCardinality(l_Attr.ClientEnd.Cardinality).Equals("1"))
{
l_MyAttr.Max = "1";
l_MyAttr.Min = "1";
// pair of attributes on same connector for Add and Remove Ref
l_MyAttr.onSameConnectorPairAtt = new EAPAttribute(l_Attr.SupplierEnd.Role, l_Attr.SupplierEnd.Alias);
}
else if (StringManipulationManager.GetMaxCardinality(l_Attr.ClientEnd.Cardinality).Equals("2"))
{
l_MyAttr.Max = "2";
l_MyAttr.Min = "0";
// pair of attributes on same connector for Add and Remove Ref
l_MyAttr.onSameConnectorPairAtt = new EAPAttribute(l_Attr.SupplierEnd.Role, l_Attr.SupplierEnd.Alias);
}
}
if (l_MyAttr.Max == "*")
{
if (pom)
{
l_MyAttr.MeasurementType = "List<" + FindClassById(l_Attr.SupplierID, MyModelCopy) + ">";
}
else
{
l_MyAttr.MeasurementType = "List<" + FindClassById(l_Attr.ClientID, MyModelCopy) + ">";
}
l_MyAttr.IsListOfReferences = true;
}
else if (l_MyAttr.Max == "1")
{
l_MyAttr.MeasurementType = "long";
l_MyAttr.IsReference = true;
}
// FindType(l_Class, l_MyAttr, l_Attr);
//l_MyAttr.Aggregated = GetAggregated(l_Attr, l_MyAttr);
// l_MyAttr.Searchable = GetSearchable(l_Attr, l_MyAttr);
// l_MyAttr.Cardinality = GetCardinality(l_Attr, l_MyAttr) == 0 ? null : GetCardinality(l_Attr, l_MyAttr).ToString();
if (!(l_Class.AddAttribute(l_MyAttr)))
{
if (Validate)
{
tw.WriteLine("Attribute Model Code:" + l_Attr.Alias + ", already exists in Class name: " + l_Class.Name + ". (Look at EAP)");
tw.WriteLine("*************************************************************************");
tw.WriteLine("\n\n");
}
}
}
public void CollectClass(EA.Element p_Elem, bool parse, EAPModel model, bool flag)
{
if (p_Elem.Name == "LID" || p_Elem.Name == "GID")
{
return;
}
// if (!model.Classes.ContainsKey(p_Elem.Name))
// {
EAPClass l_Class = new EAPClass();
EAPClass l_ClassParent = new EAPClass();
l_Class.Name = p_Elem.Name;
l_Class.Abstract = p_Elem.Abstract == "0" ? "false" : "true"; // Leaf
l_Class.Parse = parse;
//group
bool group = p_Elem.Tag == "Contained";
bool existClass = false;
//Description i title
l_Class.Description = p_Elem.Notes;
if (l_Class.Description.Split(':').Length > 1)
{
l_Class.Title = l_Class.Description.Split(':')[0];
l_Class.Description = l_Class.Description.Remove(0, l_Class.Title.Length + 1).Trim();
}
else
{
l_Class.Title = "";
l_Class.Description = l_Class.Description.Trim();
}
l_Class.Title = l_Class.Title.Replace("<b>", "").Replace("</b>", "").Replace("<i>", "").Replace("</i>", "").Trim();
l_Class.Description = l_Class.Description.Replace("<b>", "").Replace("</b>", "").Replace("<i>", "").Replace("</i>", "").Trim();
l_Class.Code = p_Elem.Alias; // ModelCode
foreach (EA.Element l_Parent in p_Elem.BaseClasses)
{
if (l_Parent.Type == "Class")
{
l_Class.Parent = l_Parent.Name;
if (group)
{
existClass = model.Classes.ContainsKey(l_Parent.Name);
if (existClass)
{
l_ClassParent = (EAPClass)model.Classes[l_Parent.Name];
}
else
{
model.GroupClasNames.Add(p_Elem.Name, l_Parent.Name);
}
}
}
}
if (!group || !existClass)
{
//collect attributes
if (flag == false)
{
AddAttributesInClass(model, p_Elem, (EAPClass)model.Classes[l_Class.Name], group);
}
}
else
{
if (flag == false)
{
AddAttributesInClass(model, p_Elem, l_ClassParent, group, l_Class);
}
}
if (!model.Classes.ContainsKey(p_Elem.Name))
{
model.Classes.Add(l_Class.Name, l_Class);
}
//import inner classes attributes as atributes
if (!group)
{
foreach (EA.Element el_Class in p_Elem.Elements)
{
CollectClass(el_Class, parse, model, flag);
}
}
}
private void GenerateEqualsMethod(CodeTypeDeclaration file, EAPClass classPom)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.Name = "Equals";
method.ReturnType = new CodeTypeReference(typeof(bool));
method.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(object)), "obj"));
CodeExpression condition = new CodeBinaryOperatorExpression(
new CodeSnippetExpression("true"),
CodeBinaryOperatorType.BooleanAnd,
new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeSnippetExpression("base"), "Equals"), new CodeSnippetExpression("obj")));
if (classPom.Attributes.Count > 0)
{
List <CodeSnippetStatement> snipets = new List <CodeSnippetStatement>()
{
new CodeSnippetStatement("\t\t\t\t" + classPom.Name + " x = " + "(" + classPom.Name + ")" + "obj;"), new CodeSnippetStatement("\t\t\t\treturn (")
};
int k = 1;
CodeSnippetStatement ste = new CodeSnippetStatement();
foreach (var item in classPom.Attributes)
{
if (classPom.Attributes.Count == 1)
{
if (item.MeasurementType.Contains("List<"))
{
ste = new CodeSnippetStatement(("\t\t\t\t(CompareHelper.CompareLists(x." + item.Name + " == " + "this." + item.Name + ",true" + "));"));
}
else
{
ste = new CodeSnippetStatement(("\t\t\t\t(x." + item.Name + " == " + "this." + item.Name + "));"));
}
snipets.Add(ste);
break;
}
if (k == classPom.Attributes.Count)
{
if (item.MeasurementType.Contains("List<"))
{
ste = new CodeSnippetStatement(("\t\t\t\t(CompareHelper.CompareLists(x." + item.Name + " == " + "this." + item.Name + ",true" + ")));"));
}
else
{
ste = new CodeSnippetStatement(("\t\t\t\t(x." + item.Name + " == " + "this." + item.Name + "));"));
}
snipets.Add(ste);
break;
}
if (item.MeasurementType != "")
{
if (item.MeasurementType.Contains("List<"))
{
ste = new CodeSnippetStatement(("\t\t\t\t(CompareHelper.CompareLists(x." + item.Name + " == " + "this." + item.Name + ",true" + ")) &&"));
}
else
{
ste = new CodeSnippetStatement(("\t\t\t\t(x." + item.Name + " == " + "this." + item.Name + ") && "));
}
snipets.Add(ste);
}
k++;
}
CodeStatement[] trueStatements = snipets.ToArray();
CodeStatement[] falseStatements = { new CodeSnippetStatement("\t\t\t\treturn false;") };
CodeConditionStatement ifStatement = new CodeConditionStatement(condition, trueStatements, falseStatements);
method.Statements.Add(ifStatement);
}
else
{
List <CodeSnippetStatement> snipets = new List <CodeSnippetStatement>()
{
new CodeSnippetStatement("\t\t\t\treturn true;")
};
CodeSnippetStatement ste = new CodeSnippetStatement();
CodeStatement[] trueStatements = snipets.ToArray();
CodeStatement[] falseStatements = { new CodeSnippetStatement("\t\t\t\treturn false;") };
CodeConditionStatement ifStatement = new CodeConditionStatement(condition, trueStatements, falseStatements);
method.Statements.Add(ifStatement);
}
file.Members.Add(method);
}
private CodeCompileUnit CreateClass(EAPModel model, EAPClass classPom, bool flagDb)
{
CodeCompileUnit unit = new CodeCompileUnit();
//namespace
CodeNamespace nameSpace = new CodeNamespace("Default_Namespace");
unit.Namespaces.Add(nameSpace);
//namespace imports
nameSpace.Imports.Add(new CodeNamespaceImport("System"));
CodeTypeDeclaration file = new CodeTypeDeclaration();
file.IsClass = true;
file.Name = classPom.Name;
file.TypeAttributes = TypeAttributes.Public;
file.Attributes = MemberAttributes.Public;
if (classPom.Parent != null)
{
file.BaseTypes.Add(new CodeTypeReference(classPom.Parent));
nameSpace.Imports.Add(new CodeNamespaceImport("Default_Namespace"));
}
else
{
//if class doesn't have a parent,
//it should extend IDClass as the root of hierarhy - for rdf:ID
file.BaseTypes.Add(new CodeTypeReference("IDClass"));
nameSpace.Imports.Add(new CodeNamespaceImport("Default_Namespace"));
}
if (!string.IsNullOrEmpty(classPom.Description))
{
file.Comments.Add(new CodeCommentStatement(classPom.Description, true));
}
//Generate constructor without param
CodeConstructor baseStringConstructorSimple = new CodeConstructor();
baseStringConstructorSimple.Attributes = MemberAttributes.Public;
//Gererating constuctor with param
CodeConstructor baseStringConstructor = new CodeConstructor();
baseStringConstructor.Attributes = MemberAttributes.Public;
baseStringConstructor.BaseConstructorArgs.Add(new CodeVariableReferenceExpression("globalId"));
baseStringConstructor.Parameters.Add(new CodeParameterDeclarationExpression("System.Int64", "globalId"));
file.Members.Add(baseStringConstructorSimple);
file.Members.Add(baseStringConstructor);
List <EAPAttribute> attributes = new List <EAPAttribute>();
if (classPom.Attributes.Count > 0)
{
foreach (EAPAttribute attribut in classPom.Attributes)
{
CodeMemberField att = null;
if (attribut.MeasurementType != "")
{
if (Enum.IsDefined(typeof(MeasurementType), attribut.MeasurementType.ToUpper()) || attribut.MeasurementType.Contains("List<") || attribut.TypeCode.Equals("Enum") ||
attribut.TypeCode.Equals("Class"))
{
if (attribut.Max == "*")
{
nameSpace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
string fieldName = attribut.Name;
att = new CodeMemberField(new CodeTypeReference("List", new CodeTypeReference[] { new CodeTypeReference(attribut.MeasurementType.Split('<', '>')[1]) }), fieldName);
att.Attributes = MemberAttributes.Private | MemberAttributes.Final;
att.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference("List", new CodeTypeReference[] { new CodeTypeReference(attribut.MeasurementType.Split('<', '>')[1]) }));
if (!string.IsNullOrEmpty(attribut.Description))
{
att.Comments.Add(new CodeCommentStatement(attribut.Description, true));
}
file.Members.Add(att);
CreatePropertyForField(file, att, true, true);
}
else
{
string fieldName = attribut.Name;
string type = attribut.MeasurementType;
// att = new CodeMemberField(StringManipulationManager.GetSystemType(type), fieldName);
if (attribut.TypeCode != null && attribut.TypeCode != "")
{
if (attribut.TypeCode.Equals("Enum"))
{
att = new CodeMemberField(attribut.MeasurementType, fieldName);
}
if (attribut.TypeCode.Equals("Class"))
{
att = new CodeMemberField(attribut.MeasurementType, fieldName);
}
}
else
{
att = new CodeMemberField(StringManipulationManager.GetSystemType(type), fieldName);
}
att.Attributes = MemberAttributes.Private | MemberAttributes.Final;
if (!string.IsNullOrEmpty(attribut.Description))
{
att.Comments.Add(new CodeCommentStatement(attribut.Description, true));
}
if (type.Equals("long") && attribut.IsReference == true)
{
att.InitExpression = new CodeSnippetExpression("0");
}
file.Members.Add(att);
//property for the field
CreatePropertyForField(file, attribut, att, true, true);
}
}
else
{
continue;
}
}
}
if (IsDbSelected && flagDb == false)
{
GenerateIDForDb(file, classPom.Name); // generate id if db checbox is selected
}
if (flagDb)
{
GenerateEqualsMethod(file, classPom);
GenerateHashCodeMethod(file, classPom);
GenerateGetProperty(file, classPom);
GenerateHasPropertyMethod(file, classPom);
GenerateSetPropertyMethod(file, classPom);
GenerateIsReferencedProperty(file, classPom);
GenerateGetReferencesMethod(file, classPom);
GenerateAddreferenceMethod(file, classPom);
GenerateRemoveReferencMethod(file, classPom);
}
}
else
{
if (flagDb)
{
GenerateEqualsMethod(file, classPom);
GenerateHashCodeMethod(file, classPom);
GenerateGetProperty(file, classPom);
GenerateHasPropertyMethod(file, classPom);
GenerateSetPropertyMethod(file, classPom);
GenerateGetReferencesMethod(file, classPom);
}
}
nameSpace.Types.Add(file);
return(unit);
}
