public static EAAPI.Element AddEmbeddedElement(this EAAPI.Element parent, EAAPI.Repository repository,
string name, string type)
{
EAAPI.Element result = null;
if (string.IsNullOrEmpty(name))
{
name = "empty";
}
if (parent.Type == "Package")
{
EAAPI.Package package = repository.GetPackageByGuid(parent.ElementGUID) as EAAPI.Package;
result = package.AddElement(name, type);
}
else
{
EAAPI.Element newElement = (EAAPI.Element)parent.Elements.AddNew(name, type);
if (!newElement.Update())
{
Debug.WriteLine(newElement.GetLastError());
}
parent.Elements.Refresh();
result = newElement;
}
return(result);
}
public static string GetClassifierName(this EAAPI.Element element, EAAPI.Repository repository)
{
string result = "";
int classiferID = 0;
if (element.Type == "Port" || element.Type == "Part" || element.Type == "ActionPin")
{
classiferID = element.PropertyType;
}
else
{
classiferID = element.ClassifierID;
}
if (classiferID != 0)
{
EAAPI.Element classifierElement = repository.GetElementByID(classiferID);
if (classifierElement != null)
{
result = classifierElement.Name;
}
}
return(result);
}
public static void SetRunStateValue(this EAAPI.Element element, string variableName, string value, string operation)
{
if (variableName != null && variableName != "")
{
Dictionary <string, ObjectRunState> runStates = ParseRunStateString(element.RunState);
if (value != null && value != "")
{
if (runStates.ContainsKey(variableName))
{
runStates[variableName].Value = value;
runStates[variableName].Operator = operation;
}
else
{
ObjectRunState runState = new ObjectRunState();
runState.Name = variableName;
runState.Value = value;
runState.Operator = operation;
runStates.Add(variableName, runState);
}
}
else
{
if (runStates.ContainsKey(variableName))
{
runStates.Remove(variableName);
}
}
element.RunState = CreateRunStateString(runStates);
element.Update();
}
}
public List <Node> GetAllHierarchies()
{
List <Node> result = new List <Node>();
EAAPI.Collection searchResult = _repository.GetElementsByQuery("SpecificationPackages", "");
if (searchResult.Count > 0)
{
for (short counter = 0; counter < searchResult.Count; counter++)
{
EAAPI.Element packageElement = searchResult.GetAt(counter) as EAAPI.Element;
EAAPI.Package package = _repository.GetPackageByGuid(packageElement.ElementGUID);
CachedDataProvider eaCacheDataProvider = new CachedDataProvider(_repository);
EADM.Element specificationPackageElement = eaCacheDataProvider.GetCachedSpecification(package);
Node rootNode = new Node();
ConvertEaDataToSpecifNodeRecursively(specificationPackageElement, rootNode);
result = rootNode.Nodes;
}
}
return(result);
}
private void ConvertEaDataToSpecifNodeRecursively(EADM.Element currentElement, Node parentNode)
{
string eaSpecIfID = EaSpecIfGuidConverter.ConvertEaGuidToSpecIfGuid(currentElement.ElementGUID);
string specIfResourceID = eaSpecIfID;
string specIfResourceRevision = "1";
if (currentElement.TaggedValues.Exists(tv => tv.Name == "specifId"))
{
specIfResourceID = currentElement.TaggedValues.First(tv => tv.Name == "specifId").Value;
specIfResourceRevision = currentElement.TaggedValues.First(tv => tv.Name == "specifRevision").Value;
}
Node node = new Node()
{
ResourceReference = new Key(specIfResourceID, specIfResourceRevision),
Description = new List <MultilanguageText> {
new MultilanguageText(currentElement.ToString())
},
ID = eaSpecIfID + "_Node"
};
parentNode.Nodes.Add(node);
foreach (EADM.Element childElement in currentElement.Elements)
{
ConvertEaDataToSpecifNodeRecursively(childElement, node);
}
}
public static EAAPI.Attribute AddAttribute(this EAAPI.Element parent, string name, string type)
{
EAAPI.Attribute attribute = (EAAPI.Attribute)parent.Attributes.AddNew(name, type);
attribute.Update();
parent.Attributes.Refresh();
return(attribute);
}
public static EAAPI.Method AddMethod(this EAAPI.Element parent, string name, string returnType = "void")
{
EAAPI.Method method = (EAAPI.Method)parent.Methods.AddNew(name, returnType); // 2nd parameter == return type
method.Update();
parent.Refresh();
return(method);
}
public static EAAPI.Connector AddConnector(this EAAPI.Element source, EAAPI.Element target, string connetcorType)
{
EAAPI.Connector connector = (EAAPI.Connector)source.Connectors.AddNew("", connetcorType);
connector.SupplierID = target.ElementID;
connector.Update();
source.Connectors.Refresh();
return(connector);
}
public static EAAPI.Element AddElement(this EAAPI.Package parentPackage, string name, string type)
{
EAAPI.Element newElement = (EAAPI.Element)parentPackage.Elements.AddNew(name, type);
newElement.Update();
parentPackage.Elements.Refresh();
parentPackage.Element.Refresh();
return(newElement);
}
public static EAAPI.Element GetClassifier(this EAAPI.Attribute attribute, EAAPI.Repository repository)
{
EAAPI.Element result = null;
if (attribute.ClassifierID != 0)
{
result = repository.GetElementByID(attribute.ClassifierID);
}
return(result);
}
public static EAAPI.Element AddEndNode(this EAAPI.Package parent)
{
EAAPI.Element result = (EAAPI.Element)parent.Elements.AddNew("End", "StateNode");
result.Subtype = 101;
result.Update();
parent.Elements.Refresh();
parent.Element.Refresh();
return(result);
}
public static string GetElementKind(this EAAPI.Element element)
{
for (short i = 0; i < element.CustomProperties.Count; i++)
{
EAAPI.CustomProperty cprop = (EAAPI.CustomProperty)element.CustomProperties.GetAt(i);
if (cprop.Name == "kind")
{
return(cprop.Value);
}
}
return("");
}
public static ObjectRunState GetRunStateByName(this EAAPI.Element element, string variableName)
{
ObjectRunState result = null;
Dictionary <string, ObjectRunState> runStates = ParseRunStateString(element.RunState);
if (runStates.ContainsKey(variableName))
{
result = runStates[variableName];
}
return(result);
}
public static string GetRunStateValue(this EAAPI.Element element, string variableName)
{
string result = "";
Dictionary <string, ObjectRunState> runStates = ParseRunStateString(element.RunState);
if (runStates.ContainsKey(variableName))
{
result = runStates[variableName].Value;
}
return(result);
}
private async void ExecuteAddSpecificationToSpecIfAsync()
{
EAAPI.Package treeSelectedPackage = _repository.GetTreeSelectedPackage();
if (treeSelectedPackage.Element.Stereotype == "specification")
{
CachedDataProvider eaCacheDataProvider = new CachedDataProvider(_repository);
EADM.Element cachedSpecification = eaCacheDataProvider.GetCachedSpecification(treeSelectedPackage);
List <EADM.Element> linearElementList = eaCacheDataProvider.GetSpecificationElementList(cachedSpecification);
List <EADM.Element> cachedRequirements = linearElementList.FindAll(el => el.Type == "Requirement" &&
!el.TaggedValues.Exists(tv => tv.Name == "specifId"));
if (cachedRequirements.Count > 0)
{
ProjectDescriptor project = ExecuteSelectProject();
if (project != null)
{
await Task.Run(() =>
{
bool error = false;
foreach (EADM.Element cachedElement in cachedRequirements)
{
EAAPI.Element element = _repository.GetElementByID(cachedElement.ElementID);
if (element != null)
{
logger.Info("Integrating requirement " + cachedElement.Name + "...");
Resource repositoryResource = _projectIntegrator.AddRequirementToSpecIF(_requirementMasterDataWriter, element, project.ID);
if (repositoryResource == null)
{
logger.Error("Error integrating requirement. Abort.");
error = true;
break;
}
}
}
if (!error)
{
logger.Info("Integration finished.");
}
});
}
}
}
}
public static List <ObjectRunState> GetObjectRunStates(this EAAPI.Element element)
{
List <ObjectRunState> result = new List <ObjectRunState>();
Dictionary <string, ObjectRunState> runStates = ParseRunStateString(element.RunState);
foreach (KeyValuePair <string, ObjectRunState> keyValuePair in runStates)
{
ObjectRunState runState = keyValuePair.Value;
result.Add(runState);
}
return(result);
}
public static EAAPI.Element GetClassifier(this EAAPI.Method method, EAAPI.Repository repository)
{
EAAPI.Element result = null;
int classifierID = 0;
if (int.TryParse(method.ClassifierID, out classifierID))
{
if (classifierID != 0)
{
result = repository.GetElementByID(classifierID);
}
}
return(result);
}
public static EAAPI.Element Copy(this EAAPI.Element source, EAAPI.Package targetPackage)
{
EAAPI.Element targetElement = (EAAPI.Element)targetPackage.Elements.AddNew(source.Name, source.Type);
targetElement.ClassifierID = source.ClassifierID;
targetElement.Stereotype = source.Stereotype;
if (source.Type == "Part")
{
targetElement.PropertyType = source.PropertyType;
}
/*
* if (source.Type == "Action")
* {
* for (int i = 0; i < source.Elements.Count; i++)
* {
* EA.Element sourceEmbeddedEl = (EA.Element) source.Elements.GetAt((short)i);
* EA.Element embeddedEl = (EA.Element) el.Elements.AddNew(sourceEmbeddedEl.Name, sourceEmbeddedEl.Type);
* embeddedEl.ClassfierID = sourceEmbeddedEl.ClassfierID;
* embeddedEl.Stereotype = sourceEmbeddedEl.Stereotype;
*
* embeddedEl.Update();
* el.Elements.Refresh();
* }
* }
*/
// copy tagged values
for (short i = 0; i < source.TaggedValues.Count; i++)
{
EAAPI.TaggedValue sourceTag = (EAAPI.TaggedValue)source.TaggedValues.GetAt(i);
EAAPI.TaggedValue targetTag = (EAAPI.TaggedValue)targetElement.TaggedValues.AddNew(sourceTag.Name, sourceTag.Value);
targetTag.Update();
}
targetElement.TaggedValues.Refresh();
targetElement.Update();
targetPackage.Elements.Refresh();
targetPackage.Element.Refresh();
return(targetElement);
}
/// <summary>
///
/// </summary>
/// <param name=""></param>
/// <param name="repository"></param>
/// <param name="element"></param>
/// <returns>The package ID.</returns>
public static int DeleteElement(this EAAPI.Repository repository, EAAPI.Element element)
{
EAAPI.Package parentPackage = repository.GetPackageForElement(element);
for (int i = 0; i < parentPackage.Elements.Count; i++)
{
EAAPI.Element el = (EAAPI.Element)parentPackage.Elements.GetAt((short)i);
if (el.ElementID == element.ElementID)
{
parentPackage.Elements.Delete((short)i);
break;
}
}
parentPackage.Elements.Refresh();
parentPackage.Update();
return(parentPackage.PackageID);
}
public static EAAPI.Element GetClassifier(this EAAPI.Element element, EAAPI.Repository repository)
{
EAAPI.Element result = null;
int classiferID = 0;
if (element.Type == "Port" || element.Type == "Part" || element.Type == "ActionPin")
{
classiferID = element.PropertyType;
}
else
{
classiferID = element.ClassifierID;
}
if (classiferID != 0)
{
result = repository.GetElementByID(classiferID);
}
return(result);
}
/// <summary>
/// Add a model element to a diagram.
/// </summary>
/// <param name="diagram">The diagram.</param>
/// <param name="element">The element to add.</param>
public static void AddElement(this EAAPI.Diagram diagram, EAAPI.Element element)
{
for (short i = 0; i < diagram.DiagramObjects.Count; i++)
{
EAAPI.DiagramObject existingDiagramObject = diagram.DiagramObjects.GetAt(i) as EAAPI.DiagramObject;
if (existingDiagramObject.ElementID == element.ElementID)
{
// Element still on diagram, return
return;
}
}
EAAPI.DiagramObject diagramObject = (EAAPI.DiagramObject)diagram.DiagramObjects.AddNew("", "");
diagramObject.ElementID = element.ElementID;
if (!diagramObject.Update())
{
Debug.WriteLine(diagramObject.GetLastError());
}
diagram.Update();
}
public static void DeleteConnector(this EAAPI.Repository repository, EAAPI.Connector con)
{
EAAPI.Element element = repository.GetElementByID(con.ClientID);
short index = -1;
for (short i = 0; i < element.Connectors.Count; i++)
{
EAAPI.Connector c = element.Connectors.GetAt(i) as EAAPI.Connector;
if (c.ConnectorID == con.ConnectorID)
{
index = i;
break;
}
}
if (index != -1)
{
element.Connectors.Delete(index);
element.Connectors.Refresh();
}
}
public static void SetTaggedValueString(this EAAPI.Element modelElement, string tagName, string value, bool isMemo = false)
{
for (short cnt = 0; cnt < modelElement.TaggedValues.Count; cnt++)
{
EAAPI.TaggedValue tag = modelElement.TaggedValues.GetAt(cnt) as EAAPI.TaggedValue;
if (tag != null && tag.Name == tagName)
{
if (!isMemo)
{
tag.Value = value;
}
else
{
tag.Value = "<memo>*";
tag.Notes = value;
}
tag.Update();
modelElement.TaggedValues.Refresh();
return;
}
}
EAAPI.TaggedValue newTag = modelElement.TaggedValues.AddNew(tagName, "") as EAAPI.TaggedValue;
if (newTag != null)
{
if (!isMemo)
{
newTag.Value = value;
}
else
{
newTag.Value = "<memo>*";
newTag.Notes = value;
}
newTag.Update();
}
modelElement.TaggedValues.Refresh();
}
public static string GetTaggedValueString(this EAAPI.Element modelElement, string tagName)
{
string result = "";
for (short count = 0; count < modelElement.TaggedValues.Count; count++)
{
EAAPI.TaggedValue taggedValue = modelElement.TaggedValues.GetAt(count) as EAAPI.TaggedValue;
if (taggedValue != null && taggedValue.Name == tagName)
{
if (!taggedValue.Value.StartsWith("<memo"))
{
result = taggedValue.Value;
}
else
{
result = taggedValue.Notes;
}
break;
}
}
return(result);
}
public static EAAPI.Package GetPackageForElement(this EAAPI.Repository repository, EAAPI.Element element)
{
return(repository.GetPackageByID(element.PackageID));
}
public static EAAPI.Element GetParentElement(this EAAPI.Element childElement, EAAPI.Repository repository)
{
return(repository.GetElementByID(childElement.ParentID));
}
public static void SetBackgroundColor(this EAAPI.Element element, int color)
{
element.SetAppearance(1, 0, color);
element.Update();
}
public static void SetBorderColor(this EAAPI.Element element, int color)
{
element.SetAppearance(1, 2, color);
element.Update();
}
/// <summary>
/// Get the DiagramObject for the given Element
/// </summary>
/// <param name="diagram">The diagram to search for the DiagramObject</param>
/// <param name="element">The element.</param>
/// <returns>The diagram object or null if not found.</returns>
public static EAAPI.DiagramObject GetDiagramObjectForElement(this EAAPI.Diagram diagram, EAAPI.Element element)
{
EAAPI.DiagramObject result = null;
for (short counter = 0; counter < diagram.DiagramObjects.Count; counter++)
{
EAAPI.DiagramObject diagramObject = diagram.DiagramObjects.GetAt(counter) as EAAPI.DiagramObject;
if (diagramObject.ElementID == element.ElementID)
{
result = diagramObject;
break;
}
}
return(result);
}
