private void button1_Click(object sender, EventArgs e)
{
Enabled = false;
Close();
string maxFile = textBox1.Text;
string schFile = textBox2.Text;
string svrlFile = textBox3.Text;
// Update Package SchematronFile
EA.TaggedValue tvSchematronFile = GetSchematronTaggedValue(repository);
tvSchematronFile.Value = schFile;
tvSchematronFile.Update();
// Create MAX file
MAX_EA.MAXExporter3 exporter = new MAX_EA.MAXExporter3();
EA.ObjectType type = repository.GetTreeSelectedItemType();
if (type == EA.ObjectType.otPackage)
{
EA.Package package = repository.GetTreeSelectedPackage();
exporter.exportPackage(repository, package, maxFile);
}
else if (type == EA.ObjectType.otDiagram)
{
EA.Diagram diagram = (EA.Diagram)repository.GetTreeSelectedObject();
exporter.exportDiagram(repository, diagram, maxFile);
}
// Execute Transform
issues = new MAXValidator().validate(repository, maxFile, schFile, svrlFile);
}
/// <summary>
/// Set Tagged Value with 'Name' to a value. If tagged value doesn't exists a new one is created.
/// </summary>
/// <param name="el"></param>
/// <param name="name"></param>
/// <param name="value"></param>
/// <returns></returns>
public static EA.TaggedValue SetTaggedValue(EA.Element el, string name, string value)
{
EA.TaggedValue tg = AddTaggedValue(el, name);
tg.Value = value;
tg.Update();
return(tg);
}
public void LoadFromRepository(EA.Repository repository)
{
element = EAHelper.GetCurrentElement(repository);
if (element != null)
{
field = element.TaggedValuesEx.GetByName("Markdown");
if(field == null)
{
field = element.TaggedValuesEx.AddNew("Markdown", "TaggedValue");
field.Value = "<memo>";
field.Update();
}
style = element.TaggedValuesEx.GetByName("MarkdownStyle");
if(style == null)
{
style = element.TaggedValuesEx.AddNew("MarkdownStyle", "TaggedValue");
style.Value = ((MarkdownStyle)this.toolstripStyleBox.SelectedItem).CSSLink;
style.Update();
}
skin = element.TaggedValuesEx.GetByName("PrettifySkin");
if (skin == null)
{
skin = element.TaggedValuesEx.AddNew("PrettifySkin", "TaggedValue");
skin.Value = this.toolStripSkinBox.SelectedItem.ToString();
skin.Update();
}
}
this.markdownTextBox.Text = field.Notes;
//UpdateWebBrowser();
}
/// <summary>
/// Sets a normal EA.Package as an UMM view package. This means, that a stereotype is
/// applied and also the taggedvalues, which every "UMM view package" inherits
/// from "BusinessLibrary" from UMM base. Additionally a package diagram is created if
/// the package is stereotyped as BDV, BRV or BTV
/// </summary>
/// <param name="package">the EA.Package which should be modified to an UMM "view package"</param>
/// <param name="stereotype">the stereotype, which should be applied</param>
/// <returns>a reference to the modified package</returns>
private EA.Package populateUMMView(EA.Package package, UMM stereotype)
{
// set the stereotype
package.Element.Stereotype = stereotype.ToString();
// add the tagged values
foreach (string tv_string in Enum.GetNames(typeof(BusinessLibraryTV)))
{
EA.TaggedValue tv = (EA.TaggedValue)package.Element.TaggedValues.AddNew(tv_string, "");
tv.Update();
}
/* if the stereotype is BRV or BCV the package is own of the core views.
* then for a more convinient modeling, a package diagram is added */
if (stereotype.Equals(UMM.bRequirementsV) || stereotype.Equals(UMM.bChoreographyV))
{
EA.Diagram diagram = (EA.Diagram)package.Diagrams.AddNew(package.Name, EA_Element.Package.ToString());
diagram.ShowDetails = 0;
diagram.Update();
}
//For the BIV we add a class diagram
else if (stereotype.Equals(UMM.bInformationV))
{
EA.Diagram diagram = (EA.Diagram)package.Diagrams.AddNew(package.Name, EA_Element.Class.ToString());
diagram.ShowDetails = 0;
diagram.Update();
}
package.Update();
return(package);
}
private EA.Element CreateChildElement(CsvReader csv, EA.Package parent, String polarionID, Dictionary <String, EA.Element> map)
{
if (map.ContainsKey(polarionID))
{
EA.Element req = map[polarionID];
req.Name = csv["Title"];
req.Notes = csv["Description"] + "\r\n\r\n\r\nMotivation\r\n" + csv["Motivation"] + "\r\n\r\n\r\nNotes\r\n" + csv["Note"];
// No need to touch polarion ID
req.PackageID = parent.PackageID;
req.ParentID = 0; // Directly owned by this Package
// TODO: Need to fiddle with parents Elements list?
req.Update();
map.Remove(polarionID);
return(req);
}
else
{
EA.Element newReq = (EA.Element)parent.Elements.AddNew(csv["Title"], "Requirement");
newReq.Notes = csv["Description"] + "\r\n\r\n\r\nMotivation\r\n" + csv["Motivation"] + "\r\n\r\n\r\nNotes\r\n" + csv["Note"];
EA.TaggedValue polID = (EA.TaggedValue)newReq.TaggedValues.AddNew("PolarionID", "String");
polID.Value = polarionID;
polID.Update();
newReq.Update();
return(newReq);
}
}
/// <summary>
/// Create Tagged Value with 'Name'. It return the TaggedValue
/// </summary>
/// <param name="el"></param>
/// <param name="name"></param>
/// <returns></returns>
public static EA.TaggedValue CreateTaggedValue(EA.Element el, string name)
{
EA.TaggedValue tg = Add(el, name);
tg.Update();
return(tg);
}
public void RefreshWebBrowser()
{
element = EAHelper.GetCurrentElement(currentRepo);
if (element != null)
{
field = element.TaggedValuesEx.GetByName("Markdown");
if (field == null)
{
field = element.TaggedValuesEx.AddNew("Markdown", "TaggedValue");
field.Value = "<memo>";
field.Update();
}
style = element.TaggedValuesEx.GetByName("MarkdownStyle");
if (style == null)
{
style = element.TaggedValuesEx.AddNew("MarkdownStyle", "TaggedValue");
style.Value = "";
style.Update();
}
skin = element.TaggedValuesEx.GetByName("PrettifySkin");
if (skin == null)
{
skin = element.TaggedValuesEx.AddNew("PrettifySkin", "TaggedValue");
skin.Value = "sunburst";
skin.Update();
}
}
StringBuilder sb = new StringBuilder();
sb.Append(String.Format("<link rel=\"stylesheet\" href=\"{0}\">", style.Value));
string s = skin.Value;
if (s != "default")
{
s = "?skin=" + s;
}
else
{
s = "";
}
string file = Path.GetTempPath() + "documentation.html";
using (FileStream fs = File.Open(file, FileMode.Create))
{
StreamWriter writer = new StreamWriter(fs);
writer.Write(Properties.Resources.HTMLHeader, sb.ToString(), s, md.Transform(field.Notes));
writer.Flush();
}
this.webBrowser1.Navigate(file);
}
/// <summary>
/// AddInformationClass
/// </summary>
/// <param name="strPackageName"></param>
/// <param name="strInfoClassName"></param>
/// <param name="strInfoClassDescription"></param>
private int AddInformationClass(EA.Package eaPackage, string strInfoClassName, string strInfoClassDescription, string strRequirements)
{
string strLogInfo = "Information Class: " + strInfoClassName;
int iErrorCount = 0;
EA.Element element1 = null;
EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);
if (eaPackage == null)
{
EAImporter.LogError(EAImporter.LogErrorLevel.A, "cannot add infomation class- package does not exist " + strInfoClassName);
iErrorCount++;
return(iErrorCount);
}
if (m_InfoClasses[strInfoClassName] != null)
{
EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
return(iErrorCount);
}
try
{
element1 = eaPackage.Elements.GetByName(strInfoClassName);
}
catch (Exception ex)
{
EAImporter.LogMsg(EAImporter.LogMsgType.MiscExceptions, ex.Message);
// EAImporter.LogMsg(EAImporter.LogMsgType.MiscExceptions, m_Repository.Stereotypes.GetLastError() + " : " + ex.Message);
}
if (element1 == null)
{
element1 = eaPackage.Elements.AddNew(strInfoClassName, "Class");
element1.Notes = strInfoClassDescription;
element1.Update();
EA.TaggedValue eaTgVal = element1.TaggedValues.AddNew("requirements", "TaggedValue");
eaTgVal.Value = strRequirements;
eaTgVal.Update();
eaPackage.Elements.Refresh();
EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);
m_InfoClasses[strInfoClassName] = element1;
}
else
{
m_InfoClasses[strInfoClassName] = element1;
EAImporter.LogMsg(EAImporter.LogMsgType.Exists, strLogInfo);
}
return(iErrorCount);
}
private bool Update(EA.TaggedValue tgdVl)
{
bool result = tgdVl.Update();
if (result == false)
{
throw new Exception("Update Didn't work out properlly!!!");
}
return(result);
}
public static void SetTaggedValue(EA.Element element, string name, string value, string notes = null)
{
DeleteTaggedValue(element, name);
EA.TaggedValue tv = (EA.TaggedValue)element.TaggedValues.AddNew(name, "TaggedValue");
tv.Value = value;
if (notes != null)
{
tv.Notes = notes;
}
tv.Update();
}
public static EA.TaggedValue setTaggedValueNotes(SQLRepository repository, EA.Package package, String name, String notes)
{
if (package.Element != null)
{
package.Element.TaggedValues.Refresh();
EA.TaggedValue aTag = setTaggedValue(repository, package, name, "<memo>");
aTag.Notes = notes;
aTag.Update();
return(aTag);
}
return(null);
}
private EA.TaggedValue GetSchematronTaggedValue(EA.Repository Repository)
{
EA.Package selectedPackage = Repository.GetTreeSelectedPackage();
EA.TaggedValue tvSchematronFile = (EA.TaggedValue)selectedPackage.Element.TaggedValues.GetByName(TV_MAX_SchematronFile);
if (tvSchematronFile == null)
{
tvSchematronFile = (EA.TaggedValue)selectedPackage.Element.TaggedValues.AddNew(TV_MAX_SchematronFile, "");
tvSchematronFile.Value = defaultSchematronFile;
tvSchematronFile.Update();
}
return(tvSchematronFile);
}
private EA.Element createEAClass(EA.Package package, EAClass eAClass)
{
EA.Element element = package.Elements.AddNew(eAClass.Name, "Class");
element.Stereotype = eAClass.StereoType;
if (EnumUtil.checkInEnumValues(eAClass.StereoType, typeof(PlatformDataTypeEnum)))
{
element.Stereotype = DATA_TYPE;
EA.TaggedValue taggedValue = element.TaggedValues.AddNew("IDLType", eAClass.StereoType);
taggedValue.Update();
}
return(element);
}
public static EA.TaggedValue setTaggedValueNotes(SQLRepository repository, EA.Element element, String name, String notes)
{
element.TaggedValues.Refresh();
EA.Element actElement = element;
if (actElement is SQLElement)
{
actElement = repository.GetOriginalRepository().GetElementByID(element.ElementID);
}
EA.TaggedValue aTag = setTaggedValue(repository, actElement, name, "<memo>");
aTag.Notes = notes;
aTag.Update();
return(aTag);
}
private void addTaggedValue(EA.Element element, string name, string value)
{
if (!string.IsNullOrEmpty(value))
{
EA.TaggedValue tv = (EA.TaggedValue)element.TaggedValues.AddNew(name, "TaggedValue");
if (value.Length > 255)
{
value = "{truncated}" + value.Substring(0, 244);
}
tv.Value = value;
tv.Update();
}
}
public bool exportPackage(EA.Repository Repository, EA.Package package, string fileName)
{
this.Repository = Repository;
progress_max = 1;
progress.setup(progress_max);
progress.Show();
Repository.EnableCache = true;
// Add/update export metadata to the model
ModelType model = new ModelType();
model.exportDate = DateTime.Now.ToString();
// Now export selected package
objects = new List <ObjectType>();
relationships = new List <RelationshipType>();
visitSelectedPackage(package.PackageID);
model.objects = objects.ToArray();
model.relationships = relationships.ToArray();
progress.Close();
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.NewLineChars = "\n";
XmlSerializer serializer = new XmlSerializer(typeof(ModelType));
using (XmlWriter writer = XmlWriter.Create(fileName, settings))
{
serializer.Serialize(writer, model);
}
// Add/update export metadata to the package
EA.TaggedValue tvExportDate = (EA.TaggedValue)package.Element.TaggedValues.GetByName("MAX::ExportDate");
if (tvExportDate == null)
{
tvExportDate = (EA.TaggedValue)package.Element.TaggedValues.AddNew("MAX::ExportDate", "");
}
tvExportDate.Value = DateTime.Now.ToString();
tvExportDate.Update();
EA.TaggedValue tvExportFile = (EA.TaggedValue)package.Element.TaggedValues.GetByName("MAX::ExportFile");
if (tvExportFile == null)
{
tvExportFile = (EA.TaggedValue)package.Element.TaggedValues.AddNew("MAX::ExportFile", "");
}
tvExportFile.Value = fileName;
tvExportFile.Update();
return(issues);
}
private EA.TaggedValue GetXsltTaggedValue(EA.Repository Repository)
{
// N.B. Model doesnot support tagged values!
EA.Package modelPackage = (EA.Package)Repository.Models.GetAt(0);
EA.Package viewPackage = (EA.Package)modelPackage.Packages.GetAt(0);
EA.TaggedValue tvXsltFile = (EA.TaggedValue)viewPackage.Element.TaggedValues.GetByName(TV_MAX_XSLTFile);
if (tvXsltFile == null)
{
tvXsltFile = (EA.TaggedValue)viewPackage.Element.TaggedValues.AddNew(TV_MAX_XSLTFile, "");
tvXsltFile.Value = defaultXsltFile;
tvXsltFile.Update();
}
return(tvXsltFile);
}
/// <summary>
/// Make a memo field out of the current TaggedValue
/// </summary>
/// <param name="el"></param>
/// <param name="name"></param>
/// <returns></returns>
public static EA.TaggedValue MakeMemo(EA.Element el, string name)
{
EA.TaggedValue tg = Add(el, name);
string value = tg.Value;
if (value.ToLower() == MemoString)
{
return(tg);
}
tg.Value = MemoString;
tg.Notes = value;
tg.Update();
return(tg);
}
public static void TaggedValueSet(EA.Element element, string tagName, string tagValue)
{
EA.TaggedValue tag = element.TaggedValues.GetByName(tagName);
if (tag == null)
{
tag = element.TaggedValues.AddNew(tagName, tagValue);
}
else
{
tag.Value = tagValue;
}
tag.Update();
//element.Update(); // is it needed?
}
/// <summary>
/// Set Tagged Value with 'Name' to a value. If tagged value doesn't exists a new one is created. If the
/// </summary>
/// <param name="el"></param>
/// <param name="name"></param>
/// <param name="value"></param>
/// <returns></returns>
public static EA.TaggedValue SetUpdate(EA.Element el, string name, string value)
{
EA.TaggedValue tg = Add(el, name);
if (value.Length > 255)
{
tg.Value = MemoString;
tg.Notes = value;
}
else
{
tg.Value = value;
}
tg.Update();
return(tg);
}
public bool exportPackage(EA.Repository Repository, EA.Package package)
{
string defaultFileName = Path.Combine(CurrentOutputPath, string.Format(@"{0}.max", package.Name));
EA.TaggedValue tvExportFile = (EA.TaggedValue)package.Element.TaggedValues.GetByName("MAX::ExportFile");
if (tvExportFile != null)
{
defaultFileName = tvExportFile.Value;
}
string fileName = showFileDialog(defaultFileName, false);
if (fileName != String.Empty)
{
if (SelectedFilter == FILTER_MAX)
{
return(new MAXExporter3().exportPackage(Repository, package, fileName));
}
else if (SelectedFilter == FILTER_EXCEL_DATASET)
{
string xsltFile = Main.getAppDataFullPath(@"XML Transforms\max-to-excel-de.xslt");
string tmpFile = fileName + ".tmp";
if (!new MAXExporter3().exportPackage(Repository, package, tmpFile))
{
tvExportFile = (EA.TaggedValue)package.Element.TaggedValues.GetByName("MAX::ExportFile");
if (tvExportFile == null)
{
tvExportFile = (EA.TaggedValue)package.Element.TaggedValues.AddNew("MAX::ExportFile", "");
}
tvExportFile.Value = fileName;
tvExportFile.Update();
return(filter(Repository, tmpFile, xsltFile, fileName));
}
else
{
return(true);
}
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public static EA.TaggedValue setTaggedValue(SQLRepository repository, EA.Element elem, String name, String value)
{
EA.Element element = elem;
if (elem is SQLElement)
{
element = repository.GetOriginalRepository().GetElementByID(elem.ElementID);
}
element.TaggedValues.Refresh();
EA.TaggedValue aTag = findTaggedValue(element, name);
if (aTag == null)
{
aTag = (EA.TaggedValue)element.TaggedValues.AddNew(name, value);
}
aTag.Value = value;
aTag.Update();
return(aTag);
}
/// <summary>
/// Get Tagged Value with 'Name'. If tagged value doesn't exists than create a new one. Don't forget to write the value and update.
/// </summary>
/// <param name="el"></param>
/// <param name="name"></param>
/// <returns></returns>
public static EA.TaggedValue Add(EA.Element el, string name)
{
foreach (EA.TaggedValue taggedValue in el.TaggedValues)
{
if (taggedValue.Name == name)
{
return(taggedValue);
}
}
// create tagged value
EA.TaggedValue tg = (EA.TaggedValue)el.TaggedValues.AddNew(name, "Tag");
tg.Update();
el.TaggedValues.Refresh();
return(tg);
}
/// <summary>
/// This methods tags a given Energistics class in order to properly generate:
/// - its base class #include directive
/// - its base class namespace
/// This methods produces no effect if the Energistics class does not inherit or if
/// its base class have no correspondinf fesapi class
/// </summary>
/// <param name="energisticsClass">An Energistics class</param>
/// <param name="fesapiClass">Its corresponding fesapi class</param>
/// <returns>the fesapi class corresponding to the Energistics base class; null if the
/// Energistics class does not inherit of if its base class
/// have no corresponding fesapi class</returns>
private EA.Element inheritanceTagging(EA.Element energisticsClass, EA.Element fesapiClass)
{
EA.Element fesapiBaseClass = null;
// we look for the fesapi class corresponding to the base class
if (energisticsClass.BaseClasses.Count != 0)
{
// important note: we assume that energistics class inherits from 1 or 0 base class
EA.Element energisticsBaseClass = energisticsClass.BaseClasses.GetAt(0);
fesapiBaseClass = fesapiClassList.Find(c => c.Name.Equals(energisticsBaseClass.Name));
}
if (fesapiBaseClass != null)
{
// we set up the #include directive to be copied in the generated code
string fesapiBaseClassPackageName = repository.GetPackageByID(fesapiBaseClass.PackageID).Name;
string fesapiClassPackageName = repository.GetPackageByID(fesapiClass.PackageID).Name;
string fesapiIncludeTagValue = "";
if (fesapiBaseClassPackageName != fesapiClassPackageName) // if the fesapi class and fesapi base class belong to a different
// package, we need to provide the relative path of the header file
{
fesapiIncludeTagValue += fesapiBaseClassPackageName + "/";
}
fesapiIncludeTagValue += fesapiBaseClass.Name + ".h";
// tagging the energistics class with the #include directive
EA.TaggedValue fesapiIncludeTag = energisticsClass.TaggedValues.AddNew(Constants.fesapiBaseClassIncludeTagName, fesapiIncludeTagValue);
if (!(fesapiIncludeTag.Update()))
{
Tool.showMessageBox(repository, fesapiIncludeTag.GetLastError());
}
// tagging the energistics class with the fesapi base class namespace (that is to say the name of its parent package)
EA.TaggedValue fesapiBaseClassNamespaceTag = energisticsClass.TaggedValues.AddNew("fesapiBaseClassNamespace", fesapiBaseClassPackageName);
if (!(fesapiBaseClassNamespaceTag.Update()))
{
Tool.showMessageBox(repository, fesapiBaseClassNamespaceTag.GetLastError());
}
energisticsClass.TaggedValues.Refresh();
}
return(fesapiBaseClass);
}
private void go(bool openOutput)
{
Enabled = false;
Close();
string maxFile = textBox1.Text;
string xsltFile = textBox2.Text;
string outputFile = textBox3.Text;
// Update project XSLTFile
EA.TaggedValue tvXsltFile = GetXsltTaggedValue(repository);
tvXsltFile.Value = xsltFile;
tvXsltFile.Update();
// Create MAX file
MAX_EA.MAXExporter3 exporter = new MAX_EA.MAXExporter3();
EA.ObjectType type = repository.GetTreeSelectedItemType();
if (type == EA.ObjectType.otPackage)
{
EA.Package package = repository.GetTreeSelectedPackage();
exporter.exportPackage(repository, package, maxFile);
}
else if (type == EA.ObjectType.otDiagram)
{
EA.Diagram diagram = (EA.Diagram)repository.GetTreeSelectedObject();
exporter.exportDiagram(repository, diagram, maxFile);
}
// Execute Transform
// TODO: Show feedback about the transform steps
if (transform(repository, maxFile, xsltFile, outputFile))
{
if (openOutput)
{
string outputURL = new Uri(outputFile).ToString();
System.Diagnostics.Process.Start(outputURL);
}
}
else
{
issues = true;
}
}
private EA.Element AddDataObject(EA.Diagram diagram, EA.Package thePackage, string strInfoExchanged, string strActorName, string strPos)
{
string strLogInfo = "Activity Info Exchanged: " + strInfoExchanged;
EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);
EA.Element eElObj = thePackage.Elements.AddNew(strInfoExchanged, "Object");
if (eElObj == null)
{
EAImporter.LogError(EAImporter.LogErrorLevel.A, strLogInfo);
return(null);
}
try
{
eElObj.ClassifierID = EAImporter.m_InfoModels.Get(strInfoExchanged).ElementID;
}
catch (Exception ex)
{
EAImporter.LogError(EAImporter.LogErrorLevel.A, "Information exchanged \"" + strInfoExchanged + "\" used in a sequence step is not defined in the Use Case or in the Repository");
string Temp = ex.Message;
return(null);
}
EA.TaggedValue eaTgVal = eElObj.TaggedValues.AddNew("ActorName", "TaggedValue");
eaTgVal.Value = strActorName;
eaTgVal.Update();
eElObj.Update();
if (AddDiagramObject(diagram, eElObj.ElementID, strPos) == null)
{
EAImporter.LogError(EAImporter.LogErrorLevel.A, strLogInfo);
return(null);
}
EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);
return(eElObj);
}
public static EA.TaggedValue setTaggedValue(SQLRepository repository, EA.Package package, String name, String value)
{
EA.Package actPackage = package;
if (actPackage is SQLPackage)
{
actPackage = repository.GetOriginalRepository().GetPackageByID(package.PackageID);
}
EA.Element element = actPackage.Element;
if (element != null)
{
EA.TaggedValue aTag = findTaggedValue(element, name);
if (aTag == null)
{
aTag = (EA.TaggedValue)element.TaggedValues.AddNew(name, value);
}
aTag.Value = value;
aTag.Update();
return(aTag);
}
return(null);
}
private void importCriteria(EA.Element functionElement, XmlNode functionNode, EA.Repository Repository)
{
string functionID = functionNode.SelectSingleNode("ID").InnerText;
XmlNodeList criteriaList = functionNode.SelectNodes("ConformanceCriteria");
foreach (XmlNode criteriaNode in criteriaList)
{
string criteriaID = String.Format("{0}#{1}", functionID, criteriaNode.SelectSingleNode("ID").InnerText);
string criteriaText = criteriaNode.SelectSingleNode("Text").InnerText;
EA.Element criteriaElement = (EA.Element)functionElement.Elements.AddNew(String.Format("{0} {1}", criteriaID, criteriaText), "Requirement");
functions.Add(criteriaID, criteriaElement);
criteriaElement.Stereotype = "Criteria";
// apply color
string chapter = functionID.Substring(0, functionID.IndexOf('.'));
if (chapterColors.ContainsKey(chapter))
{
criteriaElement.SetAppearance(1 /*Base*/, 0 /*BGCOLOR*/, chapterColors[chapter]);
}
criteriaElement.Update();
criteriaElement.Locked = LOCK_ELEMENTS;
string criteriaOpt = criteriaNode.SelectSingleNode("Optionality").InnerText;
EA.TaggedValue taggedValue = (EA.TaggedValue)criteriaElement.TaggedValues.AddNew("Optionality", "TaggedValue");
taggedValue.Value = criteriaOpt;
taggedValue.Update();
// Add a Connector from Criteria to Function
EA.Connector connector = (EA.Connector)criteriaElement.Connectors.AddNew("", "Association");
connector.SupplierID = functionElement.ElementID;
connector.Update();
XmlNodeList linkList = criteriaNode.SelectNodes("Link/FunctionID");
foreach (XmlNode id in linkList)
{
addLink(functionID, id.InnerText, Repository);
}
}
}
public static void WriteTaggedValue(EA.Collection Collection, string TaggedValueName, string Value, bool WriteValueToNotes = false)
{
EA.TaggedValue tv = Collection.GetByName(TaggedValueName);
if (tv == null)
{
tv = Collection.AddNew(TaggedValueName, "TaggedValue");
}
if (WriteValueToNotes)
{
if (tv.Notes != Value)
{
tv.Notes = Value;
}
}
else
{
if (tv.Value != Value)
{
tv.Value = Value;
}
}
tv.Update();
}
private void initElements(XmlNode xmlNode)
{
foreach (XmlNode node in xmlNode)
{
string type = node.Attributes.GetNamedItem("xmi:type").Value;
string id = node.Attributes.GetNamedItem("xmi:idref").Value;
if (type.ToLower().Contains("package"))
{
id = id.Replace("EAPK", "EAID");
EA.Package p = this.repository.GetPackageByID(eaIdPackageIdMap[id]);
p.IsProtected = node.Attributes.GetNamedItem("scope").Value != "public";
foreach (XmlNode n in node.ChildNodes)
{
switch (n.Name)
{
case "properties":
p.Element.Stereotype = n.Attributes.GetNamedItem("stereotype").Value;
p.Element.IsSpec = n.Attributes.GetNamedItem("isSpecification").Value.ToLower() == "true";
break;
case "flags":
p.IsControlled = n.Attributes.GetNamedItem("iscontrolled").Value.ToLower() == "true";
p.IsProtected = n.Attributes.GetNamedItem("isprotected").Value.ToLower() == "true";
p.BatchSave = int.Parse(n.Attributes.GetNamedItem("batchsave").Value);
p.BatchLoad = int.Parse(n.Attributes.GetNamedItem("batchload").Value);
p.UseDTD = n.Attributes.GetNamedItem("usedtd").Value.ToLower() == "true";
p.LogXML = n.Attributes.GetNamedItem("logxml").Value.ToLower() == "true";
p.Flags = n.Attributes.GetNamedItem("packageFlags").Value;
break;
default:
break;
}
}
p.Update();
}
else if (type.ToLower().Contains("class"))
{
EA.Element e = this.repository.GetElementByID(eAIdElementIdMap[id]);
foreach (XmlNode n in node.ChildNodes)
{
switch (n.Name)
{
case "model":
e.TreePos = int.Parse(n.Attributes.GetNamedItem("tpos").Value);
e.Type = n.Attributes.GetNamedItem("ea_eleType").Value;
break;
case "properties":
e.IsRoot = n.Attributes.GetNamedItem("isRoot").Value == "true";
e.IsLeaf = n.Attributes.GetNamedItem("isLeaf").Value == "true";;
e.Abstract = n.Attributes.GetNamedItem("isAbstract").Value;
e.IsActive = n.Attributes.GetNamedItem("isActive").Value == "true";
e.IsSpec = n.Attributes.GetNamedItem("isSpecification").Value == "true";
e.Type = n.Attributes.GetNamedItem("sType").Value;
e.Stereotype = n.Attributes.GetNamedItem("stereotype").Value;
break;
case "attributes":
foreach (XmlNode attNode in n.ChildNodes)
{
string attid = attNode.Attributes.GetNamedItem("xmi:idref").Value;
if (!eaIdAttibuteIdMap.ContainsKey(attid))
{
continue;
}
EA.Attribute attribute = this.repository.GetAttributeByID(eaIdAttibuteIdMap[attid]);
foreach (XmlNode valueNode in attNode.ChildNodes)
{
switch (valueNode.Name)
{
case "properties":
attribute.Type = valueNode.Attributes.GetNamedItem("type").Value;
attribute.IsDerived = valueNode.Attributes.GetNamedItem("derived").Value != "0";
attribute.IsCollection = valueNode.Attributes.GetNamedItem("collection").Value == "true";
attribute.AllowDuplicates = valueNode.Attributes.GetNamedItem("duplicates").Value != "0";
attribute.IsConst = valueNode.Attributes.GetNamedItem("changeability").Value != "changeable";
break;
case "containment":
attribute.Containment = valueNode.Attributes.GetNamedItem("containment").Value;
if (valueNode.Attributes.GetNamedItem("position") != null)
{
attribute.Pos = int.Parse(valueNode.Attributes.GetNamedItem("position").Value);
}
break;
case "bounds":
string lower = valueNode.Attributes.GetNamedItem("lower") != null?valueNode.Attributes.GetNamedItem("lower").Value : "";
string upper = valueNode.Attributes.GetNamedItem("upper") != null?valueNode.Attributes.GetNamedItem("upper").Value : "";
attribute.LowerBound = lower;
attribute.UpperBound = upper;
break;
default:
break;
}
}
}
break;
case "tags":
foreach (XmlNode tagNode in n.ChildNodes)
{
string name = tagNode.Attributes.GetNamedItem("name").Value;
string value = tagNode.Attributes.GetNamedItem("value").Value;
int index = value.IndexOf("#NOTES#");
EA.TaggedValue tv = null;
if (index == -1)
{
tv = e.TaggedValues.AddNew(name, value);
}
else
{
tv = e.TaggedValues.AddNew(name, value.Substring(0, index));
tv.Notes = value.Substring(index + 7);
}
tv.Update();
}
break;
default:
break;
}
}
e.Update();
}
else if (type.ToLower().Contains("port"))
{
EA.Element e = this.repository.GetElementByID(eAIdElementIdMap[id]);
foreach (XmlNode n in node.ChildNodes)
{
if (n.Name == "properties")
{
e.Stereotype = n.Attributes.GetNamedItem("stereotype").Value;
e.Update();
}
}
}
}
}
private EA.Element AddActivity(EA.Diagram diagram, EA.Package thePackage, string strActivityName, string strActorName, string strPos, ImportFieldsValidator oFields)
{
string strLogInfo = "Activity: " + strActivityName;
EAImporter.LogMsg(EAImporter.LogMsgType.Adding, strLogInfo);
EA.Element eElObj = null;
if (strActivityName.StartsWith("Repeat till"))
{
eElObj = thePackage.Elements.AddNew(strActivityName, "Decision");
}
else if (strActivityName.StartsWith("Wait till"))
{
eElObj = thePackage.Elements.AddNew(strActivityName, "Event");
}
else if (strActivityName == "ActivityInitial")
{
// eElObj = thePackage.Elements.AddNew("", "ActivityInitial"); // hmm does not seem to work
eElObj = thePackage.Elements.AddNew(strActivityName, "Activity");
}
else if (strActivityName == "ActivityFinal")
{
//eElObj = thePackage.Elements.AddNew("", "ActivityFinal"); // hmm does not seem to work
eElObj = thePackage.Elements.AddNew(strActivityName, "Activity");
}
else
{
eElObj = thePackage.Elements.AddNew(strActivityName, "Activity");
}
if (AddDiagramObject(diagram, eElObj.ElementID, strPos) == null)
{
EAImporter.LogError(EAImporter.LogErrorLevel.A, strLogInfo);
return(null);
}
if (oFields != null)
{
eElObj.Notes = oFields["description"].Value;
EA.TaggedValue eaTgVal = eElObj.TaggedValues.AddNew("event", "TaggedValue");
eaTgVal.Value = oFields["event"].Value;
eaTgVal.Update();
eaTgVal = eElObj.TaggedValues.AddNew("number", "TaggedValue");
eaTgVal.Value = oFields["number"].Value;
eaTgVal.Update();
eaTgVal = eElObj.TaggedValues.AddNew("requirements", "TaggedValue");
eaTgVal.Value = oFields["requirements"].Value;
eaTgVal.Update();
eaTgVal = eElObj.TaggedValues.AddNew("ActorName", "TaggedValue");
eaTgVal.Value = strActorName;
eaTgVal.Update();
eElObj.Update();
}
EAImporter.LogMsg(EAImporter.LogMsgType.Added, strLogInfo);
return(eElObj);
}
public static void sync_element_taggedvalue(EA.Repository Repository, EA.Element sample, EA.Element classifier, JObject jo, EA.Package pkg, DiagramCache diagramCache)
{
logger.log("Syncing JObject:" + sample.Name);
EA.Collection taggedValues = sample.TaggedValues;
if (classifier != null)
{
sample.ClassifierID = classifier.ElementID;
}
foreach (JProperty p in jo.Properties())
{
if (p.Name == RoundTripAddInClass.POPULATION_PROPERTY_GUID)
{
continue;
}
if (p.Name == RoundTripAddInClass.CONSTRAINT_PROPERTY_SOURCE || p.Name == RoundTripAddInClass.CONSTRAINT_PROPERTY_TARGET)
{
continue;
}
if (p.Name == RoundTripAddInClass.CONSTRAINT_PROPERTY_CLASS || p.Name == RoundTripAddInClass.CONSTRAINT_PROPERTY_STEREOTYPE)
{
continue;
}
if (p.Name == RoundTripAddInClass.POPULATION_PROPERTY_PACKAGE)
{
continue;
}
if (p.Name == RoundTripAddInClass.POPULATION_PROPERTY_NAME)
{
sample.Name = p.Value.ToString();
continue;
}
if (p.Name == RoundTripAddInClass.POPULATION_PROPERTY_NOTES)
{
sample.Notes = p.Value.ToString();
continue;
}
if (p.Name == RoundTripAddInClass.POPULATION_PROPERTY_TYPE)
{
string classifierName = p.Value.ToString();
EA.Element clazz = RepositoryHelper.queryClassifier(Repository, classifierName);
if (clazz != null)
{
sample.ClassifierID = clazz.ElementID;
continue;
}
else
{
continue;
}
}
if (p.Value.Type != JTokenType.Object && p.Value.Type != JTokenType.Array)
{
//logger.log("Handling Property:" + p.Name);
EA.TaggedValue r = taggedValues.GetByName(p.Name);
if (r != null)
{
//logger.log("Existing Tag");
r.Value = p.Value.ToString();
r.Update();
}
else
{
//logger.log("New Tag");
EA.TaggedValue tv = sample.TaggedValues.AddNew(p.Name, RoundTripAddInClass.EA_TYPE_STRING);
tv.Value = p.Value.ToString();
tv.Update();
}
}
}
sample.Update();
}