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); }