public void GenerateCode(EAPModel model)
{
FilesComplete.Clear();
FilesForDb.Clear();
foreach (var item in model.Classes)
{
DictionaryEntry table = (DictionaryEntry)item;
CodeCompileUnit unit = BuildCodeCUnit(model, table.Value, true);
if (IsDbSelected)
{
CodeCompileUnit unitDb = BuildCodeCUnit(model, table.Value, false);
if (unitDb != null)
{
FilesForDb.Add(unitDb);
}
}
if (unit != null)
{
//add it to the list, unless its null
FilesComplete.Add(unit);
}
}
if (IsDbSelected)
{
CodeCompileUnit unitDb = CreateDBContextClass(model);
FilesForDb.Add(unitDb);
}
// CreateParentClass(); // ovo treba izbaciti za IdentifiedObject
}
private CodeCompileUnit BuildCodeCUnit(EAPModel model, object v, bool flagDb)
{
CodeCompileUnit unit = null;
EAPClass classPom = (EAPClass)v;
unit = CreateClass(model, classPom, flagDb);
return(unit);
}
public void CollectEnums(EA.Element elem, bool parse, EAPModel model)
{
if (!model.Enums.ContainsKey(elem.Name))
{
EAPEnumeration en = new EAPEnumeration();
en.Name = elem.Name;
en.Code = elem.Alias;
en.Description = elem.Notes;
en.Bitfield = elem.Stereotype.Contains("bitfield");
en.Parse = parse;
if (en.Description.Split(':').Length > 1)
{
en.Title = en.Description.Split(':')[0];
en.Description = en.Description.Remove(0, en.Title.Length + 1).Trim();
}
else
{
en.Title = "";
en.Description = en.Description.Trim();
}
en.Title = en.Title.Replace("<b>", "").Replace("</b>", "").Replace("<i>", "").Replace("</i>", "").Trim();
en.Description = en.Description.Replace("<b>", "").Replace("</b>", "").Replace("<i>", "").Replace("</i>", "").Trim();
foreach (EA.Attribute l_Attr in elem.Attributes)
{
CollectEnumValue(l_Attr, en);
}
model.Enums.Add(en.Name, en);
if (Validate && !en.Parse && en.EnumValue.Count != 0)
{
tw.WriteLine("Model Code for enum: {0},", en.Code);
tw.WriteLine("Name for enum: {0},\n", en.Name);
tw.WriteLine("Enum name:" + en.Name + ", was not being processed but it has enum value.");
tw.WriteLine("*************************************************************************");
tw.WriteLine("\n\n");
}
}
else
{
if (Validate)
{
tw.WriteLine("Enum name:" + elem.Name + ", already exists in EAP.");
tw.WriteLine("*************************************************************************");
tw.WriteLine("\n\n");
}
}
}
public EAPModels CollectClasses(string input, ref string err)
{
m_Repository = new EA.Repository();
try
{
m_Repository.OpenFile(input);
}
catch
{
err = err + "\nIt is not able to open EAP file. Check the instalation of EAP";
return(null);
}
eapModels = new EAPModels();
EAPModel model = null;
EA.Package MyModel = (EA.Package)m_Repository.Models.GetAt(0);
string packageAlias = MyModel.Packages.Count > 0 ? ((EA.Package)(MyModel.Packages.GetAt(0))).Alias : null;
if (packageAlias == null || packageAlias == "")
{
model = new EAPModel(nameModel);
eapModels.Models.Add(model);
}
for (short iPackage = 0; iPackage < MyModel.Packages.Count; iPackage++)
{
EA.Package package = (EA.Package)MyModel.Packages.GetAt(iPackage);
MyModelCopy = package;
DoPackage(package, false, model, true);
}
for (short iPackage = 0; iPackage < MyModel.Packages.Count; iPackage++)
{
EA.Package package = (EA.Package)MyModel.Packages.GetAt(iPackage);
MyModelCopy = package;
DoPackage(package, false, model, false);
}
FindAttributeEnumCode();
FixGroupClass();
m_Repository.CloseFile();
if (Validate)
{
//FindModelCodeIsNotEAP();
tw.Close();
}
return(eapModels);
}
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 CodeCompileUnit CreateDBContextClass(EAPModel model)
{
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 = DbName;
file.TypeAttributes = TypeAttributes.Public;
file.Attributes = MemberAttributes.Public;
nameSpace.Types.Add(file);
return(unit);
}
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);
}
}
}
public void DoPackage(EA.Package MyPackage, bool domain, EAPModel model, bool flag)
{
bool parse = true;
try
{
parse = (int)Convert.ToDouble(MyPackage.Version) != 1 ? false : true;
}
catch
{
parse = false;
}
if (MyPackage.Name == "Domain")
{
domain = true;
}
//string packageAlias = MyPackage.Alias;
//if (packageAlias != null && packageAlias != "")
//{
// string nameXml = System.IO.Path.GetFileNameWithoutExtension(nameModel);
// string path = nameModel.Replace(nameXml, packageAlias);
// model = new EAPModel(path);
// eapModels.Models.Add(model);
//}
//else if (model == null)
// return;
MyModelCopy = MyPackage;
if (flag)
{
for (short i = 0; i < MyPackage.Elements.Count; i++)
{
EA.Element MyElem = (EA.Element)MyPackage.Elements.GetAt(i);
if (MyElem.MetaType.Equals("Enumeration", StringComparison.InvariantCultureIgnoreCase))
{
CollectEnums(MyElem, parse, model);
}
if (MyElem.Type.Equals("Class", StringComparison.InvariantCultureIgnoreCase))
{
CollectClass(MyElem, parse, model, flag);
}
}
}
else
{
for (short i = 0; i < MyPackage.Elements.Count; i++)
{
EA.Element MyElem = (EA.Element)MyPackage.Elements.GetAt(i);
if (MyElem.Type.Equals("Class", StringComparison.InvariantCultureIgnoreCase))
{
CollectClass(MyElem, parse, model, flag);
}
}
}
if (!parse)
{
if (Validate)
{
tw.WriteLine("Package name:" + MyPackage.Name + ", - not processed.");
tw.WriteLine("*************************************************************************");
tw.WriteLine("\n\n");
}
}
for (short iPackage = 0; iPackage < MyPackage.Packages.Count; iPackage++)
{
DoPackage((EA.Package)MyPackage.Packages.GetAt(iPackage), domain, model, flag);
}
}
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);
}
