public void Save(PackageConnectionSettingsModel PackageConnectionSettings)
{
string QueryValue;
switch (PackageConnectionSettings.Type)
{
case PackageConnectionSettingsType.Jql:
QueryValue = PackageConnectionSettings.Jql;
break;
case PackageConnectionSettingsType.EpicsAndStories:
QueryValue = PackageConnectionSettings.EpicsAndStoriesJql;
break;
case PackageConnectionSettingsType.UserSearch:
QueryValue = PackageConnectionSettings.UserSavedSearch;
break;
default:
throw new NotImplementedException();
}
package.Element.Stereotype = EAGoatJira.PackageStereotypeName;
package.Element.Update();
package.Update();
package.Element.TaggedValues.Refresh();
EAUtils.WriteTaggedValue(package.Element.TaggedValues, EAGoatJira.TagValueNamePackageJql, QueryValue);
EAUtils.WriteTaggedValue(package.Element.TaggedValues, EAGoatJira.TagValueNamePackageType, PackageConnectionSettings.Type.ToString());
package.Update();
}
public EA.Package CreateEAPackage(EA.Repository Repository, string packageName, EA.Package parentPackage)
{
/// <summary>
/// Create EA package from root or as sub-package
/// <paramref name="Repository"/> Active repository
/// <paramref name="packageName"/> Name of the new package
/// <paramref name="parentPackage"/> Name of the parent package (root if empty)
/// </summary>
EA.Collection collection = Repository.Models; // Get model collection
EA.Package rootPackage = collection.GetAt(0);
EA.Package package = null;
EAUtils activeRepository = new EAUtils(Repository);
if (rootPackage != null)
{
EA.Package startPackage = rootPackage;
if (parentPackage != null)
{
// Check from the parent package
startPackage = parentPackage;
}
// Check if a package with packageName already exists
package = activeRepository.GetPackageByName(startPackage, packageName);
if (package != null)
{
// Package exists and we start collect all elements in a dictionary for performance reasons
SetEAElementInPackage(package);
}
}
if (rootPackage != null && package == null && parentPackage == null)
{
// Package does not exist and no parent package, create a new package in the root package
package = rootPackage.Packages.AddNew(packageName, "");
package.Update();
package.Element.Stereotype = "model";
}
else if (rootPackage != null && package == null && parentPackage != null)
{
// Package does not exist, create a new package from the parent package
package = parentPackage.Packages.AddNew(packageName, "");
package.Update();
package.Element.Stereotype = "model";
}
else if (package == null)
{
// Create a new root package
package = collection.AddNew(packageName, "Package");
package.Update();
}
return(package);
}
private void importPackage(EA.Package topPackage, EAPackage rootPackage)
{
EA.Package package = topPackage.Packages.AddNew(defaultPackageName, "");
package.Element.Stereotype = rootPackage.StereoType;
package.Update();
topPackage.Packages.Refresh();
}
/// <summary>
/// adds a package with the given Stereotype as a Subpackage to the given package
/// </summary>
/// <param name="package">The package, which is the parent of the newly created package</param>
/// <param name="cStereotype">The stereotype of which the newly created package should be type of</param>
/// <param name="name">The name of the package to add</param>
///
internal EA.Package addViewPackage(EA.Package package, UMM cStereotype, String name, EA_Element diagramType)
{
// at first add the new package to the parent package
EA.Package childPackage = (EA.Package)package.Packages.AddNew(name, "");
childPackage.Update();
childPackage = this.populateUMMView(childPackage, cStereotype);
/* also add the child package to the package diagram contained in the parent
* package, if wanted. if the package diagram doenst exist than create it */
EA.Diagram packageDiagram = (EA.Diagram)childPackage.Diagrams.AddNew(childPackage.Name, diagramType.ToString());
packageDiagram.ShowDetails = 0;
packageDiagram.Update();
/* now add the child package to the package diagram of the parent */
EA.Collection diagramObjects = packageDiagram.DiagramObjects;
EA.DiagramObject diagramObject = (EA.DiagramObject)diagramObjects.AddNew("l=200;r=400;t=200;b=600;", "");
diagramObject.ElementID = childPackage.Element.ElementID;
diagramObject.Update();
repository.RefreshModelView(package.PackageID);
return(childPackage);
}
private void mergeDiagrams(EA.Repository repository, EA.Package package)
{
Dictionary <int, EA.DiagramObject> dobjects = new Dictionary <int, EA.DiagramObject>();
Dictionary <int, EA.DiagramLink> dlinks = new Dictionary <int, EA.DiagramLink>();
foreach (EA.Diagram diagram in package.Diagrams)
{
foreach (EA.DiagramObject dobject in diagram.DiagramObjects)
{
dobjects[dobject.ElementID] = dobject;
}
foreach (EA.DiagramLink dlink in diagram.DiagramLinks)
{
dlinks[dlink.ConnectorID] = dlink;
}
}
EA.Diagram mdiagram = (EA.Diagram)package.Diagrams.AddNew(string.Format("{0} (Merged)", package.Name), "Custom");
mdiagram.Update();
// copy objects
int left = 10;
int top = 10;
const int width = 100;
const int height = 80;
const int padding = 10;
foreach (EA.DiagramObject dobject in dobjects.Values)
{
EA.Element element = repository.GetElementByID(dobject.ElementID);
if ("Boundary".Equals(element.Type))
{
continue;
}
string dimensions = string.Format("l={0};r={1};t={2};b={3};", left, left + width, top, top + height);
left += padding + width;
EA.DiagramObject mobject = (EA.DiagramObject)mdiagram.DiagramObjects.AddNew(dimensions, "");
mobject.ElementID = element.ElementID;
mobject.Update();
if (left == 1000)
{
left = 10;
top += height;
}
}
mdiagram.Update();
// copy links (o.a. NoteLinks)
foreach (EA.DiagramLink dlink in dlinks.Values)
{
EA.DiagramLink mlink = (EA.DiagramLink)mdiagram.DiagramLinks.AddNew("", "");
mlink.ConnectorID = dlink.ConnectorID;
mlink.Update();
}
package.Update();
repository.OpenDiagram(mdiagram.DiagramID);
}
/// <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);
}
public override void doEaGuiStuff()
{
base.doEaGuiStuff();
EA.Package newTGGProject = EAUtil.sqlEAObjectToOriginalObject(Repository, this.EaPackage) as EA.Package;
newTGGProject.Element.StereotypeEx = TGGModelingMain.TggSchemaPackageStereotype;
newTGGProject.Update();
newTGGProject.Element.Update();
}
public static void syncPopulation(EA.Repository Repository, EA.Diagram diagram, DiagramCache diagramCache)
{
logger.log("Sync Population");
RepositoryHelper.createDiagramCache(Repository, diagram, diagramCache);
IList <EA.Element> diagramElements = diagramCache.elementsList;
//IList<EA.Element> samples = MetaDataManager.diagramSamples(Repository, diagramElements);
IList <EA.Element> samples = diagramElements;
EA.Element container = container = MetaDataManager.findContainer(Repository, diagram, diagramCache, RoundTripAddInClass.EA_STEREOTYPE_POPULATION);
logger.log("Classifier ID:" + container.ClassifierID);
string containerName = container.Name;
string containerClassifier = "Classes";
EA.Element containerClassifierEl = null;
if (container.ClassifierID != 0)
{
containerClassifierEl = Repository.GetElementByID(container.ClassfierID);
containerName = container.Name;
containerClassifier = containerClassifierEl.Name;
}
EA.Package samplePkg = Repository.GetPackageByID(diagram.PackageID);
Hashtable ht = new Hashtable();
MetaDataManager.extractDiagramMetaData(ht, container);
string project = (String)ht[RoundTripAddInClass.PROJECT];
if (project == null)
{
MessageBox.Show("No project defined in the Population stereotyped element. Please enter project name where population should be exported.");
return;
}
if (fileManager != null)
{
fileManager.initializeAPI(project);
fileManager.setDataName(RoundTripAddInClass.POPULATION_PATH);
fileManager.setup(RoundTripAddInClass.RAML_0_8);
if (!fileManager.populationExists(container.Name, containerClassifier, RoundTripAddInClass.POPULATION_PATH, container.Name))
{
MessageBox.Show("No file exists at:" + fileManager.exportPath(container.Name, containerClassifier, RoundTripAddInClass.POPULATION_PATH, container.Name));
return;
}
else
{
string fullpath = fileManager.exportPath(containerName, containerClassifier, RoundTripAddInClass.POPULATION_PATH, container.Name);
JArray jo = JArray.Parse(File.ReadAllText(fullpath));
sync_population(Repository, container, containerClassifierEl, jo, samplePkg, diagramCache);
samplePkg.Update();
}
}
}
public EA.Element CreateEAElement(Item innovatorItem, EA.Package classPackage)
{
/// <summary>
/// <paramref name="innovatorItem"/> Innovator Item (ItemType)
/// <paramref name="classPackage"/> EA Package (Innovator/ItemTypes or Innovator/RelationshipTypes)
/// </summary>
string itemID = innovatorItem.getID();
EA.Element returnElement = GetEAElementByInnovatorID(itemID);
if (returnElement == null)
{
// Dictionary may be empty, so we need to check by using the package
// Unfortunately this check is much slower
returnElement = GetEAElementInPackage(innovatorItem, classPackage);
}
if (returnElement == null)
{
DateTime createdOn = Tools.GetDate(innovatorItem.getProperty("created_on", ""));
string innovatorModifiedOn = innovatorItem.getProperty("modified_on", "");
// In rare cases the modified_on date is empty
DateTime modifiedOn = DateTime.Parse("1900-01-01", CultureInfo.InvariantCulture);
if (innovatorModifiedOn != "")
{
modifiedOn = Tools.GetDate(innovatorItem.getProperty("modified_on", ""));
}
string implementationType = innovatorItem.getProperty("implementation_type");
switch (implementationType)
{
case "table": // TODO: polymorphic, federated need to be implemented
case null: // relationship type
EA.Element classElement = classPackage.Elements.AddNew(innovatorItem.getProperty("name"), "Table");
classElement.Alias = innovatorItem.getProperty("label");
classElement.Notes = innovatorItem.getProperty("description", "");
classElement.Created = createdOn;
if (modifiedOn > createdOn)
{
classElement.Modified = modifiedOn;
}
classElement.Version = innovatorItem.getProperty("generation", "");
classElement.Tag = "[PLM]" + itemID;
classElement.Update();
classPackage.Update();
returnElement = classElement;
break;
default:
break;
}
}
if (!elementDictionary.ContainsKey(itemID))
{
elementDictionary.Add(itemID, returnElement);
}
return(returnElement);
}
public override void doEaGuiStuff()
{
base.doEaGuiStuff();
EA.Package realPackage = EaPackage.getRealPackage();
if (realPackage.Element.Stereotype != TGGModelingMain.TggRulePackageStereotype)
{
realPackage.Element.StereotypeEx = TGGModelingMain.TggRulePackageStereotype;
realPackage.Update();
}
}
public override void doEaGuiStuff()
{
EA.Package realPackage = EaPackage.getRealPackage();
if (realPackage.Element.Stereotype != ECOREModelingMain.EPackageStereotype)
{
realPackage.Element.StereotypeEx = ECOREModelingMain.EPackageStereotype;
realPackage.Update();
}
updateToStandardTaggedValues();
}
/// <summary>
/// Delete undefined Reference (former ExternalReference).The element subtype is "1001". It searches for
/// </summary>
/// <returns></returns>
/// Search for External references
/// Select ea_guid As CLASSGUID, object_type As CLASSTYPE,ea_GUID As el_guid, name As el_name, * from t_object o where NType=1001
private static void DeleteUndefinedReference(EA.Repository repository, EA.Element el, Boolean dialog = true, Boolean completePackage = false)
{
//if (el.Type.Equals("Boundary"))
if (el.Subtype == 1001 && completePackage == false)
{
EA.Package pkg = repository.GetPackageByID(el.PackageID);
// Not version controlled, checked out to this user
int versionControlState = pkg.VersionControlGetStatus();
if (versionControlState == 0 || versionControlState == 2)
{
// delete External Reference
for (short idx = (short)(pkg.Elements.Count - 1); idx >= 0; idx--)
{
if ((el.ElementID == ((EA.Element)pkg.Elements.GetAt(idx)).ElementID) || (completePackage && el.Subtype == 1001))
{
// with or without dialog
try
{
if (dialog)
{
DialogResult res = MessageBox.Show("Delete element '" + el.Name + "'", "Delete element", MessageBoxButtons.YesNo);
if (res == DialogResult.Yes)
{
pkg.Elements.DeleteAt(idx, false);
if (completePackage == false)
{
break;
}
}
}
else
{
pkg.Elements.DeleteAt(idx, false);
if (completePackage == false)
{
break;
}
}
}
catch { }
}
}
pkg.Update();
}
else
{
string s = String.Format("Delete element '{0}' Version control state={1} not possible!", el.Name, versionControlState);
MessageBox.Show(s, "Package can't be changed, checked in?, break;");
}
}
return;
}
public void TestInit()
{
Repos = new EA.Repository();
Repos.OpenFile(PROJECT_PATH + "MAX-TestCases.eap");
// clean temp packages
EA.Package tempPackage = Repos.GetPackageByGuid(GUID_TEMP_PACKAGE);
for (short p = 0; p < tempPackage.Packages.Count; p++)
{
tempPackage.Packages.Delete(p);
}
tempPackage.Update();
}
private bool Update(EA.Package pkg)
{
bool result = pkg.Update();
pkg.Packages.Refresh();
pkg.Elements.Refresh();
if (result == false)
{
throw new Exception("Update Didn't work out properlly!!!");
}
return(result);
}
public void TestMinimalImports()
{
EA.Package selectedPackage = (EA.Package)Repos.GetPackageByGuid(GUID_TEMP_PACKAGE).Packages.AddNew(Guid.NewGuid().ToString(), "Package");
selectedPackage.Update();
new MAXImporter3().import(Repos, selectedPackage, PROJECT_PATH + @"TestCases\minimal-nothing.max.xml");
Assert.IsTrue(selectedPackage.Elements.Count == 0 && selectedPackage.Packages.Count == 0);
new MAXImporter3().import(Repos, selectedPackage, PROJECT_PATH + @"TestCases\minimal-both-empty.max.xml");
Assert.IsTrue(selectedPackage.Elements.Count == 0 && selectedPackage.Packages.Count == 0);
new MAXImporter3().import(Repos, selectedPackage, PROJECT_PATH + @"TestCases\minimal-objects.max.xml");
Assert.IsTrue(selectedPackage.Elements.Count == 0 && selectedPackage.Packages.Count == 0);
new MAXImporter3().import(Repos, selectedPackage, PROJECT_PATH + @"TestCases\minimal-relationships.max.xml");
Assert.IsTrue(selectedPackage.Elements.Count == 0 && selectedPackage.Packages.Count == 0);
}
/// <summary>
/// This method copies an element (for instance a class) into a target package
/// note : the EA SDK does not provide a simple way to clone an element. It only
/// provides a way to clone a package in the same parent package. We use this capabilities
/// to clone an element from one package to another
/// </summary>
/// <param name="repository">The current repository</param>
/// <param name="sourceElement">An element to copy</param>
/// <param name="targetPackage">The target package</param>
/// <returns>The newly-created element or null of the copy fails</returns>
public static EA.Element copyElement(EA.Repository repository, EA.Element sourceElement, EA.Package targetPackage)
{
// we get the parent package of the source element
EA.Package sourcePackage = repository.GetPackageByID(sourceElement.PackageID);
// create an temporary package into the parent package
EA.Package tmpPackage = sourcePackage.Packages.AddNew("tmp", "");
if (!(tmpPackage.Update()))
{
return(null);
}
sourcePackage.Packages.Refresh();
// move the source element into the temporary package
sourceElement.PackageID = tmpPackage.PackageID;
sourceElement.Update();
sourcePackage.Elements.Refresh();
tmpPackage.Elements.Refresh();
// clone the temporary package
EA.Package clonePackage = tmpPackage.Clone();
clonePackage.Update();
sourcePackage.Packages.Refresh();
// move back the source element into it original parent package
sourceElement.PackageID = sourcePackage.PackageID;
sourceElement.Update();
tmpPackage.Elements.Refresh();
sourcePackage.Elements.Refresh();
// getting the copy of the source element
EA.Element targetElement = clonePackage.Elements.GetByName(sourceElement.Name);
// move the copy into the targetPackage
targetElement.PackageID = targetPackage.PackageID;
targetElement.Update();
clonePackage.Elements.Refresh();
targetPackage.Elements.Refresh();
// delete the temporary packages
short tmpPackageIndex = getIndex(sourcePackage, tmpPackage);
short clonePackageIndex = getIndex(sourcePackage, clonePackage);
sourcePackage.Packages.Delete(tmpPackageIndex);
sourcePackage.Packages.Refresh();
sourcePackage.Packages.Delete(clonePackageIndex);
sourcePackage.Packages.Refresh();
repository.RefreshModelView(sourcePackage.PackageID);
return(targetElement);
}
private void addPackageOrClass(EA.Package parentPackage, XmlNode xmlNode)
{
EA.Package p = parentPackage.Packages.AddNew(xmlNode.Attributes.GetNamedItem("name").Value, "Package");
p.Update();
eaIdPackageIdMap[xmlNode.Attributes.GetNamedItem("xmi:id").Value] = p.PackageID;
PackageId2EAId[p.PackageID] = xmlNode.Attributes.GetNamedItem("xmi:id").Value;
foreach (XmlNode childrenNode in xmlNode.ChildNodes)
{
string type = childrenNode.Attributes.GetNamedItem("xmi:type").Value;
switch (type)
{
case "uml:Class":
this.addClass(p, childrenNode);
break;
case "uml:Package":
this.addPackageOrClass(p, childrenNode);
break;
default: break;
}
}
foreach (XmlNode childrenNode in xmlNode.ChildNodes)
{
string type = childrenNode.Attributes.GetNamedItem("xmi:type").Value;
switch (type)
{
case "uml:Association":
this.addAssociation(p, childrenNode);
break;
case "uml:Dependency":
this.addDependency(p, childrenNode);
break;
case "uml:Realisation":
this.addRealisation(p, childrenNode);
break;
case "uml:Realization":
this.addRealisation(p, childrenNode);
break;
case "uml:InformationFlow":
this.addInformationFlow(p, childrenNode);
break;
default: break;
}
}
}
public EA.Package getOrCreatePackage(SQLPackage rootPackage, MocaNode packageNode)
{
String oldGuid = packageNode.getAttributeOrCreate(Main.GuidStringName).Value;
EA.Package modelPackage = repository.GetPackageByGuid(oldGuid);
if (modelPackage != null)
{
DeleteWithGuid(rootPackage, oldGuid);
EA.Package parent = repository.GetPackageByID(modelPackage.ParentID);
DeleteWithGuid(parent, oldGuid);
}
EA.Package rootPackageOriginal = rootPackage.getRealPackage();
String packageName = packageNode.getAttributeOrCreate(MetamodelHelper.MoflonCustomNameTaggedValueName).Value;
if (packageName == "")
{
packageName = packageNode.getAttributeOrCreate("name").Value;
}
modelPackage = rootPackageOriginal.Packages.AddNew(packageName, "") as EA.Package;
if (rootPackageOriginal.ParentID == 0)
{
modelPackage.Flags = "isModel=1;VICON=3;";
}
modelPackage.Update();
// import nsUri
setTagValueIfPossibleForPackage(MetamodelHelper.MoflonCustomNsUriTaggedValueName, packageNode, modelPackage);
// import export
setTagValueIfPossibleForPackage(MetamodelHelper.MoflonExportTaggedValueName, packageNode, modelPackage);
// import pluginID
setTagValueIfPossibleForPackage(MetamodelHelper.MoflonCustomPluginIDTaggedValueName, packageNode, modelPackage);
// import prefix
setTagValueIfPossibleForPackage(MetamodelHelper.MoflonCustomNsPrefixTaggedValueName, packageNode, modelPackage);
// import validated
setTagValueIfPossibleForPackage(MetamodelHelper.MoflonValidatedTaggedValueName, packageNode, modelPackage);
// import name
setTagValueIfPossibleForPackage(MetamodelHelper.MoflonCustomNameTaggedValueName, packageNode, modelPackage);
repository.Execute("update t_package set ea_guid = '" + oldGuid + "' where ea_guid = '" + modelPackage.PackageGUID + "'");
repository.Execute("update t_object set ea_guid = '" + oldGuid + "' where ea_guid = '" + modelPackage.PackageGUID + "'");
modelPackage = repository.GetPackageByGuid(oldGuid);
return(modelPackage);
}
public static void SynchronizePackageWithJIRA(EA.Repository Repository, EA.Package Package, PackageConnectionSettingsViewModel PackageConnectionSettings, JiraConnection JiraConnection)
{
//Steps:
// 1. User must be able to login to JIRA -- must ensure caller
// 2. Creating Repository.Output -- well... am thinking about event, JTS so far
// 3. Get the proper JQL -- i will get from parameter
// 4. Do to job
Repository.CreateOutputTab(EAGoatJira.JiraOutputWindowName);
Repository.EnsureOutputVisible(EAGoatJira.JiraOutputWindowName);
Repository.ClearOutput(EAGoatJira.JiraOutputWindowName);
Repository.WriteOutput(EAGoatJira.JiraOutputWindowName, "Reading data...", 0);
PackageConnectionSettings.Refresh();
Dictionary <string, EA.Element> IssuesInEA = ReadIssuesFromEA(Repository, Package.Elements);
var issues = JiraConnection.GetJiraIssues(PackageConnectionSettings.Jql);
foreach (var issue in issues)
{
EA.Element EAElementForIssue = SynchronizeItem(issue, Repository, Package, null, IssuesInEA);
if (PackageConnectionSettings.PackageConnectionSettings.Type == PackageConnectionSettingsType.EpicsAndStories)
{
var epicissues = JiraConnection.GetJiraIssues($"\"Epic Link\" = {issue.Key}");
foreach (var epicissue in epicissues)
{
SynchronizeItem(epicissue, Repository, Package, EAElementForIssue, IssuesInEA);
}
}
EAElementForIssue.Update();
}
if (IssuesInEA.Count > 0)
{ //some issues that are in the Package are not in the issues (they were deleted or moved or the Jql has chaned)
EA.Package PackageForRemovedIssues = EAUtils.CreatePackage(Package, "Removed Issues", ForceCreation: false);
foreach (var removedItem in IssuesInEA)
{
Repository.WriteOutput(EAGoatJira.JiraOutputWindowName, $"Removing issue {removedItem.Key}", removedItem.Value.ElementID);
removedItem.Value.PackageID = PackageForRemovedIssues.PackageID;
removedItem.Value.Update();
EAUtils.WriteTaggedValue(removedItem.Value, EAGoatJira.TagValueNameOperation, "Issue was " + IssueOperation.Removed.ToString() + ".", WriteValueToNotes: false);
}
PackageForRemovedIssues.Update();
}
Package.Update();
Repository.WriteOutput(EAGoatJira.JiraOutputWindowName, $"Done.", 0);
}
private void setTagValueIfPossibleForPackage(String tagNameInNode, MocaNode node, EA.Package eaPack)
{
MocaAttribute attribute = node.getAttribute(tagNameInNode);
if (attribute != null)
{
EAEcoreAddin.Util.EAUtil.setTaggedValue(sqlRep, eaPack, tagNameInNode, attribute.Value);
}
else
{
EAEcoreAddin.Util.EAUtil.deleteTaggedValue(eaPack.Element, tagNameInNode);
}
eaPack.Update();
}
///
/// Validate all object run state keys correspond to classifier attributes
///
//static public void validateDiagram(EA.Repository Repository,EA.Diagram diagram)
//{
// IList<string> messages = diagramValidation(Repository,diagram);
// logger.log("**ValidationResults**");
// if(messages!=null)
// {
// foreach (string m in messages)
// {
// logger.log(m);
// }
// }
//}
//static public IList<string> diagramValidation(EA.Repository Repository, EA.Diagram diagram,IList<EA.Element> diagramElements)
//{
// JSchema jschema = null;
// JObject json = null;
// try
// {
// //logger.log("Validate Sample");
// json = (JObject)sampleToJObject(Repository, diagram, diagramElements)["json"];
// //logger.log("JObject formed");
// EA.Package samplePkg = Repository.GetPackageByID(diagram.PackageID);
// EA.Package samplesPackage = Repository.GetPackageByID(samplePkg.ParentID);
// EA.Package apiPackage = Repository.GetPackageByID(samplesPackage.ParentID);
// EA.Package schemaPackage = null;
// foreach (EA.Package p in apiPackage.Packages)
// {
// if (p!=null && p.Name.Equals(RoundTripAddInClass.API_PACKAGE_SCHEMAS))
// {
// schemaPackage = p;
// }
// }
// if (schemaPackage == null)
// {
// throw new Exception("No Schema package found");
// }
// EA.Diagram schemaDiagram = null;
// foreach (EA.Diagram d in schemaPackage.Diagrams)
// {
// if (d.Stereotype != null && d.Stereotype.Equals(RoundTripAddInClass.EA_STEREOTYPE_SCHEMADIAGRAM))
// {
// schemaDiagram = d;
// }
// }
// jschema = SchemaManager.schemaToJsonSchema(Repository, schemaDiagram,diagramElements).Value;
// }
// catch (ModelValidationException ex)
// {
// return ex.errors.messages;
// }
// IList<string> messages;
// if (!json.IsValid(jschema, out messages))
// {
// logger.log("Sample is not valid:");
// return messages;
// }
// else{
// logger.log("Sample is Valid!");
// return null;
// }
//}
public static void syncHierarchy(EA.Repository Repository, EA.Diagram diagram, DiagramCache diagramCache)
{
logger.log("Sync Hierarchy");
RepositoryHelper.createDiagramCache(Repository, diagram, diagramCache);
//IList<EA.Element> diagramElements = diagramCache.elementsList;
IList <EA.Element> samples = MetaDataManager.diagramSamples(Repository, diagramCache.elementsList);
EA.Element container = container = MetaDataManager.findContainer(Repository, diagram, diagramCache, RoundTripAddInClass.EA_STEREOTYPE_HIERARCHY);
EA.Element containerClassifierEl = diagramCache.elementIDHash[container.ClassfierID];
string containerName = container.Name;
string containerClassifier = containerClassifierEl.Name;
Hashtable ht = new Hashtable();
MetaDataManager.extractDiagramMetaData(ht, container);
EA.Package samplePkg = Repository.GetPackageByID(diagram.PackageID);
string sourcecontrolPackage = (string)ht[RoundTripAddInClass.PROJECT];
if (fileManager != null)
{
fileManager.initializeAPI(sourcecontrolPackage);
fileManager.setDataName(RoundTripAddInClass.HIERARCHY_PATH);
fileManager.setup(RoundTripAddInClass.RAML_0_8);
if (!fileManager.populationExists(container.Name, containerClassifier, RoundTripAddInClass.HIERARCHY_PATH, container.Name))
{
MessageBox.Show("No file exists at:" + fileManager.exportPath(container.Name, containerClassifier, RoundTripAddInClass.HIERARCHY_PATH, container.Name));
return;
}
else
{
string fullpath = fileManager.exportPath(containerName, containerClassifier, RoundTripAddInClass.HIERARCHY_PATH, container.Name);
JArray jo = JArray.Parse(File.ReadAllText(fullpath));
sync_hierarchy(Repository, diagram, container, jo, samplePkg, diagramCache);
samplePkg.Update();
diagram.DiagramLinks.Refresh();
if (!diagram.Update())
{
logger.log(diagram.GetLastError());
}
}
}
}
private void TestRoundtrip(string guidPackageToTest)
{
// Export TestCase
string fileNameExport1 = TEMP_PATH + "max-export1.xml";
MAXExporter3 exporter1 = new MAXExporter3();
exporter1.exportPackage(Repos, Repos.GetPackageByGuid(guidPackageToTest), fileNameExport1);
EA.Package selectedPackage = (EA.Package)Repos.GetPackageByGuid(GUID_TEMP_PACKAGE).Packages.AddNew(Guid.NewGuid().ToString(), "Package");
selectedPackage.Update();
string guidExport2 = selectedPackage.PackageGUID;
MAXImporter3 importer = new MAXImporter3();
importer.import(Repos, selectedPackage, fileNameExport1);
selectedPackage.Packages.Refresh();
// Export Imported TestCase
string guidImport2 = ((EA.Package)selectedPackage.Packages.GetAt(0)).PackageGUID;
string fileNameExport2 = TEMP_PATH + "max-export2.xml";
MAXExporter3 exporter2 = new MAXExporter3();
exporter2.exportPackage(Repos, Repos.GetPackageByGuid(guidImport2), fileNameExport2);
// compare export1 with export2
// IGNORE @exportDate & <modified> elements. We know those will be different.
XElement export1 = XElement.Load(fileNameExport1);
export1.Attribute("exportDate").Remove();
foreach (XElement mod in export1.XPathSelectElements("//object/modified"))
{
mod.Remove();
}
export1.Save(fileNameExport1);
XElement export2 = XElement.Load(fileNameExport2);
export2.Attribute("exportDate").Remove();
foreach (XElement mod in export2.XPathSelectElements("//object/modified"))
{
mod.Remove();
}
export2.Save(fileNameExport2);
Assert.AreEqual(export1.ToString(), export2.ToString());
// delete tempPackage & temp files
}
/// <summary>
/// Creates new package in ParentPackage. If ForceCreation is false and package with the same Name exists, this package is returned insted of creation of a new one.
/// </summary>
/// <param name="ParentPackage">Parent package where the new package should be created.</param>
/// <param name="Name">Name of a new package.</param>
/// <param name="ForceCreation">If true, new package is always created.
/// If false and package with the same Name in ParentPackage already exists, this package is returned insted of creation of a new one.</param>
/// <returns>Required package</returns>
public static EA.Package CreatePackage(EA.Package ParentPackage, string Name, bool ForceCreation)
{
if (!ForceCreation)
{
foreach (EA.Package Subpackage in ParentPackage.Packages)
{
if (Subpackage.Name == Name)
{
return(Subpackage);
}
}
}
EA.Package result = ParentPackage.Packages.AddNew(Name, "Package");
result.Update();
ParentPackage.Packages.Refresh();
return(result);
}
private void okButton_Click(object sender, EventArgs e)
{
if (this.selectedSourceMetamodel != null && this.selectedTargetMetamodel != null)
{
//create rule package
if (newTGGProject.Packages.Count == 0)
{
EA.Package rulesPackage = newTGGProject.getRealPackage().Packages.AddNew("Rules", TGGModelingMain.TggRulePackageStereotype) as EA.Package;
rulesPackage.Update();
TGGRulePackage rPackage = new TGGRulePackage(repository.GetPackageByID(rulesPackage.PackageID), repository);
rPackage.saveTreeToEATaggedValue(true);
EA.Diagram rulesDiagram = rulesPackage.Diagrams.AddNew("Rules", TGGModelingMain.TggRulesDiagramMetatype[0]) as EA.Diagram;
rulesDiagram.Update();
newTGGProject.Packages.Refresh();
}
Metamodel sourceMetamodel = new Metamodel(repository, this.selectedSourceMetamodel);
Metamodel targetMetamodel = new Metamodel(repository, this.selectedTargetMetamodel);
Metamodel correspondenceMetamodel = new Metamodel(repository, repository.GetPackageByID(newTGGProject.PackageID));
Domain sourceDomain = new Domain(sourceMetamodel, DomainType.SOURCE);
Domain targetDomain = new Domain(targetMetamodel, DomainType.TARGET);
Domain correspondenceDomain = new Domain(correspondenceMetamodel, DomainType.CORRESPONDENCE);
tgg.Metamodels.Clear();
tgg.Domains.Clear();
tgg.Metamodels.Add(sourceMetamodel);
tgg.Metamodels.Add(targetMetamodel);
tgg.Metamodels.Add(correspondenceMetamodel);
tgg.Domains.Add(sourceDomain);
tgg.Domains.Add(targetDomain);
tgg.Domains.Add(correspondenceDomain);
tgg.EaPackage.getRealPackage().Name = textBoxName.Text;
tgg.saveTreeToEATaggedValue(true);
Close();
}
}
public override void save(EA.Repository rep, FindAndReplaceItem.FieldType fieldType)
{
_pkg = rep.GetPackageByGuid(GUID);
if ((fieldType & FindAndReplaceItem.FieldType.Description) > 0)
{ _pkg.Notes = _Description; }
if ((fieldType & (FindAndReplaceItem.FieldType.Name | FindAndReplaceItem.FieldType.Stereotype) ) > 0)
{
// model don't have an element
if (_pkg.ParentID != 0)
{
EA.Element el = rep.GetElementByGuid(GUID);
el.StereotypeEx = _Stereotype;
el.Name = _Name;
el.Update();
}
_pkg.Name = _Name;
}
_isUpdated = true;
_pkg.Update();
}
///
/// Validate all object run state keys correspond to classifier attributes
///
//static public void validateDiagram(EA.Repository Repository, EA.Diagram diagram)
//{
// IList<string> messages = diagramValidation(Repository, diagram);
// logger.log("**ValidationResults**");
// if (messages != null)
// {
// foreach (string m in messages)
// {
// logger.log(m);
// }
// }
//}
//static public IList<string> diagramValidation(EA.Repository Repository, EA.Diagram diagram)
//{
// JSchema jschema = null;
// JObject json = null;
// try
// {
// //logger.log("Validate Sample");
// json = (JObject)sampleToJObject(Repository, diagram)["json"];
// //logger.log("JObject formed");
// EA.Package samplePkg = Repository.GetPackageByID(diagram.PackageID);
// EA.Package samplesPackage = Repository.GetPackageByID(samplePkg.ParentID);
// EA.Package apiPackage = Repository.GetPackageByID(samplesPackage.ParentID);
// EA.Package schemaPackage = null;
// foreach (EA.Package p in apiPackage.Packages)
// {
// if (p != null && p.Name.Equals(RoundTripAddInClass.API_PACKAGE_SCHEMAS))
// {
// schemaPackage = p;
// }
// }
// if (schemaPackage == null)
// {
// throw new Exception("No Schema package found");
// }
// EA.Diagram schemaDiagram = null;
// foreach (EA.Diagram d in schemaPackage.Diagrams)
// {
// if (d.Stereotype != null && d.Stereotype.Equals(RoundTripAddInClass.EA_STEREOTYPE_SCHEMADIAGRAM))
// {
// schemaDiagram = d;
// }
// }
// jschema = SchemaManager.schemaToJsonSchema(Repository, schemaDiagram).Value;
// }
// catch (ModelValidationException ex)
// {
// return ex.errors.messages;
// }
// IList<string> messages;
// if (!json.IsValid(jschema, out messages))
// {
// logger.log("Sample is not valid:");
// return messages;
// }
// else
// {
// logger.log("Sample is Valid!");
// return null;
// }
//}
public static void syncMapping(EA.Repository Repository, EA.Diagram diagram, DiagramCache diagramCache)
{
logger.log("Sync Mapping");
RepositoryHelper.createDiagramCache(Repository, diagram, diagramCache);
IList <EA.Element> diagramElements = diagramCache.elementsList;
IList <EA.Element> samples = MetaDataManager.diagramSamples(Repository, diagramElements);
EA.Element container = container = MetaDataManager.findContainer(Repository, diagram, diagramCache, RoundTripAddInClass.EA_STEREOTYPE_MAPPING);
EA.Element containerClassifierEl = diagramCache.elementIDHash[container.ClassfierID];
string containerName = container.Name;
string containerClassifier = containerClassifierEl.Name;
EA.Package samplePkg = Repository.GetPackageByID(diagram.PackageID);
Hashtable ht = new Hashtable();
MetaDataManager.extractDiagramMetaData(ht, container);
string project = (String)ht[RoundTripAddInClass.PROJECT];
if (fileManager != null)
{
fileManager.initializeAPI(project);
fileManager.setDataName(RoundTripAddInClass.MAPPING_PATH);
fileManager.setup(RoundTripAddInClass.RAML_0_8);
if (!fileManager.populationExists(container.Name, containerClassifier, RoundTripAddInClass.MAPPING_PATH, container.Name))
{
MessageBox.Show("No file exists at:" + fileManager.exportPath(container.Name, containerClassifier, RoundTripAddInClass.MAPPING_PATH, container.Name));
return;
}
else
{
string fullpath = fileManager.exportPath(containerName, containerClassifier, RoundTripAddInClass.MAPPING_PATH, container.Name);
JArray jo = JArray.Parse(File.ReadAllText(fullpath));
sync_mapping(Repository, diagram, container, containerClassifierEl, jo, samplePkg, diagramCache);
samplePkg.Update();
}
}
}
public override void save(EA.Repository rep, FindAndReplaceItem.FieldType fieldType)
{
_pkg = rep.GetPackageByGuid(GUID);
if ((fieldType & FindAndReplaceItem.FieldType.Description) > 0)
{
_pkg.Notes = _Description;
}
if ((fieldType & (FindAndReplaceItem.FieldType.Name | FindAndReplaceItem.FieldType.Stereotype)) > 0)
{
// model don't have an element
if (_pkg.ParentID != 0)
{
EA.Element el = rep.GetElementByGuid(GUID);
el.StereotypeEx = _Stereotype;
el.Name = _Name;
el.Update();
}
_pkg.Name = _Name;
}
_isUpdated = true;
_pkg.Update();
}
public override void Save(EA.Repository rep, FindAndReplaceItem.FieldType fieldType)
{
_pkg = rep.GetPackageByGuid(Guid);
if ((fieldType & FindAndReplaceItem.FieldType.Description) > 0)
{
_pkg.Notes = Description;
}
if ((fieldType & (FindAndReplaceItem.FieldType.Name | FindAndReplaceItem.FieldType.Stereotype)) > 0)
{
// package has an object
if (_pkg.ParentID != 0)
{
EA.Element el = rep.GetElementByGuid(Guid);
el.StereotypeEx = Stereotype;
el.Name = Name;
el.Update();
}
_pkg.Name = Name;
}
IsUpdated = true;
_pkg.Update();
}
public EA.Package findOrCreateRoot(MocaNode ePackageNode)
{
EA.Package rootPackage = null;
String workingSetName = ePackageNode.getAttributeOrCreate(MetamodelHelper.MoflonWorkingSetTaggedValueName).Value;
if (workingSetName == "")
{
if (repository.Models.Count > 0)
{
rootPackage = repository.Models.GetAt(0) as EA.Package;
}
}
else
{
foreach (EA.Package root in repository.Models)
{
if (root.Name == workingSetName)
{
rootPackage = root;
}
}
}
if (rootPackage == null)
{
String rootName = workingSetName;
if (rootName == "")
{
rootName = "My Working Set";
}
rootPackage = repository.Models.AddNew(rootName, "") as EA.Package;
rootPackage.Update();
repository.Models.Refresh();
}
return(rootPackage);
}
public static bool CreateActivityForOperation(EA.Repository rep, EA.Method m)
{
// get class
EA.Element elClass = rep.GetElementByID(m.ParentID);
EA.Package pkgSrc = rep.GetPackageByID(elClass.PackageID);
// create a package with the name of the operation
EA.Package pkgTrg = (EA.Package)pkgSrc.Packages.AddNew(m.Name, "");
pkgTrg.Update();
pkgSrc.Packages.Refresh();
// create Class Activity Diagram in target package
EA.Diagram pkgActDia = (EA.Diagram)pkgTrg.Diagrams.AddNew("Operation:" + m.Name + " Content", "Activity");
pkgActDia.Update();
pkgTrg.Diagrams.Refresh();
// add frame in Activity diagram
EA.DiagramObject frmObj = (EA.DiagramObject)pkgActDia.DiagramObjects.AddNew("l=100;r=400;t=25;b=50", "");
EA.Element frm = (EA.Element)pkgTrg.Elements.AddNew(m.Name, "UMLDiagram");
frm.Update();
frmObj.ElementID = frm.ElementID;
//frmObj.Style = "fontsz=200;pitch=34;DUID=265D32D5;font=Arial Narrow;bold=0;italic=0;ul=0;charset=0;";
frmObj.Update();
pkgTrg.Elements.Refresh();
pkgActDia.DiagramObjects.Refresh();
// create activity with the name of the operation
EA.Element act = (EA.Element)pkgTrg.Elements.AddNew(m.Name, "Activity");
act.Notes = "Generated from Operation:\r\n" + m.Visibility + " " + m.Name + ":" + m.ReturnType + ";\r\nDetails see Operation definition!!";
act.Update();
pkgTrg.Elements.Refresh();
// create activity diagram beneath Activity
EA.Diagram actDia = (EA.Diagram)act.Diagrams.AddNew(m.Name, "Activity");
actDia.Update();
act.Diagrams.Refresh();
// put the activity on the diagram
EA.DiagramObject actObj = (EA.DiagramObject)actDia.DiagramObjects.AddNew("l=50;r=600;t=100;b=800", "");
actObj.ElementID = act.ElementID;
actObj.Update();
actDia.DiagramObjects.Refresh();
// add default nodes (init/final)
CreateDefaultElementsForActivity(rep, actDia, act);
// Add Heading to diagram
EA.DiagramObject noteObj = (EA.DiagramObject)actDia.DiagramObjects.AddNew("l=40;r=700;t=25;b=50", "");
EA.Element note = (EA.Element)pkgTrg.Elements.AddNew("Text", "Text");
note.Notes = m.Visibility + " " + elClass.Name + "_" + m.Name + ":" + m.ReturnType;
note.Update();
noteObj.ElementID = note.ElementID;
noteObj.Style = "fontsz=200;pitch=34;DUID=265D32D5;font=Arial Narrow;bold=0;italic=0;ul=0;charset=0;";
noteObj.Update();
pkgTrg.Elements.Refresh();
actDia.DiagramObjects.Refresh();
// Link Operation to activity
Util.SetBehaviorForOperation(rep, m, act);
// Set show behavior
Util.SetShowBehaviorInDiagram(rep, m);
// add parameters to activity
GetParameterFromOperation(rep, act, m);
Util.SetFrameLinksToDiagram(rep, frm, actDia); // link Overview frame to diagram
frm.Update();
//rep.ReloadDiagram(actDia.DiagramID);
return(true);
}
public static bool CreateInteractionForOperation(EA.Repository rep, EA.Method m)
{
// get class
EA.Element elClass = rep.GetElementByID(m.ParentID);
EA.Package pkgSrc = rep.GetPackageByID(elClass.PackageID);
// create a package with the name of the operation
EA.Package pkgTrg = (EA.Package)pkgSrc.Packages.AddNew(m.Name, "");
pkgTrg.Update();
pkgSrc.Packages.Refresh();
// create Class Sequence Diagram in target package
EA.Diagram pkgSeqDia = (EA.Diagram)pkgTrg.Diagrams.AddNew("Operation:" + m.Name + " Content", "Sequence");
pkgSeqDia.Update();
pkgTrg.Diagrams.Refresh();
// add frame in Sequence diagram
EA.DiagramObject frmObj = (EA.DiagramObject)pkgSeqDia.DiagramObjects.AddNew("l=100;r=400;t=25;b=50", "");
EA.Element frm = (EA.Element)pkgTrg.Elements.AddNew(m.Name, "UMLDiagram");
frm.Update();
frmObj.ElementID = frm.ElementID;
//frmObj.Style = "fontsz=200;pitch=34;DUID=265D32D5;font=Arial Narrow;bold=0;italic=0;ul=0;charset=0;";
frmObj.Update();
pkgTrg.Elements.Refresh();
pkgSeqDia.DiagramObjects.Refresh();
// create Interaction with the name of the operation
EA.Element seq = (EA.Element)pkgTrg.Elements.AddNew(m.Name, "Interaction");
seq.Notes = "Generated from Operation:\r\n" + m.Visibility + " " + m.Name + ":" + m.ReturnType + ";\r\nDetails see Operation definition!!";
seq.Update();
pkgTrg.Elements.Refresh();
// create sequence diagram beneath Interaction
EA.Diagram seqDia = (EA.Diagram)seq.Diagrams.AddNew(m.Name, "Sequence");
seqDia.Update();
seq.Diagrams.Refresh();
// create instance from class beneath Interaction
EA.Element obj = (EA.Element)seq.Elements.AddNew("", "Object");
seq.Elements.Refresh();
obj.ClassfierID = elClass.ElementID;
obj.Update();
// add node object to Sequence Diagram
EA.DiagramObject node = (EA.DiagramObject)seqDia.DiagramObjects.AddNew("l=100;r=180;t=50;b=70", "");
node.ElementID = obj.ElementID;
node.Update();
// Add Heading to diagram
EA.DiagramObject noteObj = (EA.DiagramObject)seqDia.DiagramObjects.AddNew("l=40;r=700;t=10;b=25", "");
EA.Element note = (EA.Element)pkgTrg.Elements.AddNew("Text", "Text");
note.Notes = m.Visibility + " " + elClass.Name + "_" + m.Name + ":" + m.ReturnType;
note.Update();
noteObj.ElementID = note.ElementID;
noteObj.Style = "fontsz=200;pitch=34;DUID=265D32D5;font=Arial Narrow;bold=0;italic=0;ul=0;charset=0;";
noteObj.Update();
pkgTrg.Elements.Refresh();
seqDia.DiagramObjects.Refresh();
// Link Operation to activity
Util.SetBehaviorForOperation(rep, m, seq);
// Set show behavior
Util.SetShowBehaviorInDiagram(rep, m);
Util.SetFrameLinksToDiagram(rep, frm, seqDia); // link Overview frame to diagram
frm.Update();
//rep.ReloadDiagram(actDia.DiagramID);
return(true);
}
