/// <summary>
/// Deserializes the TaggedValue from the tagged Object
/// </summary>
/// <returns></returns>
public Boolean loadTreeFromTaggedValue()
{
String tagNotes = "";
Object mocaTag = null;
Object objectToBeTagged = getObjectToBeTagged();
if (objectToBeTagged is SQLElement)
{
mocaTag = EAUtil.findTaggedValue(objectToBeTagged as SQLElement, Main.MoflonExportTreeTaggedValueName);
}
else if (objectToBeTagged is SQLConnector)
{
mocaTag = EAUtil.findTaggedValue(objectToBeTagged as SQLConnector, Main.MoflonExportTreeTaggedValueName);
}
else if (objectToBeTagged is SQLPackage)
{
mocaTag = EAUtil.findTaggedValue(objectToBeTagged as SQLPackage, Main.MoflonExportTreeTaggedValueName);
}
else if (objectToBeTagged is SQLMethod)
{
mocaTag = EAUtil.findTaggedValue(Repository.GetOriginalRepository().GetMethodByID((objectToBeTagged as SQLMethod).MethodID), Main.MoflonExportTreeTaggedValueName);
}
if (mocaTag is SQLTaggedValue)
{
tagNotes = (mocaTag as SQLTaggedValue).Notes;
}
else if (mocaTag is SQLConnectorTag)
{
tagNotes = (mocaTag as SQLConnectorTag).Notes;
}
else if (mocaTag is EA.MethodTag)
{
tagNotes = (mocaTag as EA.MethodTag).Notes;
}
if (tagNotes != "")
{
XmlDocument xmlDocument = MocaTreeUtil.stringToXmlDocument(tagNotes);
MocaNode emptyMocaNode = new MocaNode();
//fill mocanode from xmlElement
emptyMocaNode.deserializeFromXmlTree(xmlDocument.FirstChild.FirstChild as XmlElement);
//fill this from mocanode
try
{
deserializeFromMocaTree(emptyMocaNode);
}
catch
{
return(false);
}
return(true);
}
return(false);
}
protected void setDefaultValueIfNecessary(String tagName)
{
SQLTaggedValue tag = EAUtil.findTaggedValue(package.EaPackage, tagName);
if (tag == null)
{
EAUtil.setTaggedValue(package.Repository, package.EaPackage.getRealPackage(), tagName, DEFAULT_VALUE_PLACEHOLDER);
}
}
private static void handleObsoleteTaggedValue(SQLPackage eaPackage, List <String> results, String tag)
{
SQLTaggedValue validationFilter = EAUtil.findTaggedValue(eaPackage, tag);
if (validationFilter != null)
{
results.Add("The tagged value " + tag + " is obsolete and should be deleted or renamed appropriately.");
}
}
private static void transformConstraintToCSPElement(SQLElement eaElement2, SQLWrapperClasses.SQLRepository sqlRep, EA.Repository repository)
{
EA.Element eaElement = EAUtil.sqlEAObjectToOriginalObject(sqlRep, eaElement2) as EA.Element;
String result = repository.SQLQuery("select Diagram_ID from t_diagramobjects where Object_ID = " + eaElement.ElementID);
string diagramId = EAUtil.getXMLNodeContentFromSQLQueryString(result, "Diagram_ID")[0];
if (diagramId != "")
{
EA.Diagram diagram = repository.GetDiagramByID(int.Parse(diagramId));
EA.DiagramObject oldDiagObject = EAUtil.findDiagramObject(sqlRep, eaElement, diagram);
EA.Element ruleElement = repository.GetElementByID(diagram.ParentID);
if (ruleElement.Stereotype == TGGModelingMain.TggRuleStereotype)
{
List <EA.Connector> outgoingCons = new List <EA.Connector>();
foreach (EA.Connector con in eaElement.Connectors)
{
if (con.Stereotype == "ConstraintLink" && con.ClientID == eaElement.ElementID)
{
outgoingCons.Add(con);
}
}
EA.Element newCsp = ruleElement.Elements.AddNew("", Main.EAClassType) as EA.Element;
newCsp.Notes = eaElement.Notes;
newCsp.Stereotype = TGGModelingMain.CSPConstraintStereotype;
newCsp.Update();
EA.TaggedValue oldTag = EAUtil.findTaggedValue(eaElement, Main.MoflonExportTreeTaggedValueName);
if (oldTag != null)
{
EAUtil.setTaggedValueNotes(sqlRep, newCsp, oldTag.Name, oldTag.Notes);
}
EA.DiagramObject newDiagObject = diagram.DiagramObjects.AddNew("", Main.EAClassType) as EA.DiagramObject;
newDiagObject.ElementID = newCsp.ElementID;
newDiagObject.left = oldDiagObject.left;
newDiagObject.right = oldDiagObject.right;
newDiagObject.bottom = oldDiagObject.bottom;
newDiagObject.top = oldDiagObject.top;
newDiagObject.Update();
foreach (EA.Connector con in outgoingCons)
{
con.ClientID = newCsp.ElementID;
con.Update();
}
EAUtil.deleteDiagramObject(repository, diagram, eaElement);
EAUtil.deleteElement(eaElement, sqlRep);
}
}
}
public static bool isIgnored(SQLElement taggedObject)
{
SQLTaggedValue taggedValue = EAUtil.findTaggedValue(taggedObject, IGNORED_TAG_NAME);
if (taggedValue != null && "true".Equals(taggedValue.Value))
{
return(true);
}
return(false);
}
public static String getOppositeTextOfReference(SQLConnector con)
{
SQLConnectorTag oppositetextOfRefTag = EAUtil.findTaggedValue(con, "textOfReferenceOpposite");
if (oppositetextOfRefTag != null)
{
return(oppositetextOfRefTag.Value);
}
return("");
}
public static string setOvMethodCallExpressionGui(ObjectVariable ov)
{
SQLTaggedValue mceVisTag = EAUtil.findTaggedValue(ov.sqlElement, ObjectVariable.MceVisualizationTaggedValueName);
Expression BindingExpression = ov.BindingExpression;
if (BindingExpression != null)
{
deletePossibleBindingConnectors(ov.sqlElement.getRealElement());
if (BindingExpression is MethodCallExpression)
{
var mcE = BindingExpression as MethodCallExpression;
ObjectVariableExpression firstOvExpression = null;
if (mcE.OwnedParameterBinding.Count == 1 && (mceVisTag == null || mceVisTag.Value == "true"))
{
foreach (ParameterBinding paramBinding in mcE.OwnedParameterBinding)
{
if (paramBinding.ValueExpression is ObjectVariableExpression)
{
firstOvExpression = paramBinding.ValueExpression as ObjectVariableExpression;
}
}
if (firstOvExpression != null)
{
EA.Element firstOvEaElement = ov.Repository.GetOriginalRepository().GetElementByGuid(firstOvExpression.ObjectVariableGUID);
if (firstOvEaElement.ParentID == ov.sqlElement.ParentID)
{
EA.Connector bindingLink = firstOvEaElement.Connectors.AddNew("", Main.EADependencyType) as EA.Connector;
bindingLink.Stereotype = SDMModelingMain.BindingExpressionLinkStereotype;
bindingLink.Name = mcE.Target + "." + mcE.MethodName;
bindingLink.SupplierID = ov.sqlElement.ElementID;
bindingLink.Update();
EA.Element realElement = ov.sqlElement.getRealElement();
realElement.Connectors.Refresh();
realElement.Notes = "";
realElement.Update();
EAUtil.setTaggedValue(ov.Repository, realElement, ObjectVariable.BindingExpressionOutputTaggedValueName, "");
return("");
}
}
}
}
return(BindingExpression.ToString());
}
return("");
}
public static void setAnchorElementTags(SQLRepository sqlRepository, EA.Diagram callDiagram, SQLElement sdmContainer)
{
String anchorElementId = EAUtil.getXMLNodeContentFromSQLQueryString(sqlRepository.SQLQuery("select Object_ID from t_object where ParentID = " + sdmContainer.ElementID + " AND Stereotype = '" + SDMModelingMain.SDMAnchorStereotype + "'"), "Object_ID")[0];
if (anchorElementId != "")
{
SQLElement anchorElement = sqlRepository.GetElementByID(int.Parse(anchorElementId));
if (EAUtil.findTaggedValue(anchorElement, SDMAnchorDiagramIDTaggedValueName) == null)
{
EAUtil.setTaggedValue(sqlRepository, anchorElement.getRealElement(), SDMAnchorDiagramIDTaggedValueName, callDiagram.DiagramID.ToString());
}
}
}
public override List <string> doRule(SQLWrapperClasses.SQLConnector eaConnector, SQLWrapperClasses.SQLRepository repository)
{
var result = new List <String>();
if (eaConnector.Stereotype == SDMModelingMain.LinkVariableStereotype || eaConnector.Stereotype == TGGModelingMain.TggLinkVariableStereotype)
{
SQLConnectorTag tag = EAUtil.findTaggedValue(eaConnector, ObjectVariable.BindingSemanticsTaggedValueName);
if (tag != null && tag.Value.ToLower() == "optional")
{
result.Add("Optional ist not supported anymore");
}
}
return(result);
}
public override List <string> doRule(SQLWrapperClasses.SQLElement sqlElement, SQLWrapperClasses.SQLRepository sqlRepository)
{
var result = new List <String>();
if (sqlElement.Stereotype == SDMModelingMain.ObjectVariableStereotype || sqlElement.Stereotype == TGGModelingMain.TggObjectVariableStereotype)
{
SQLTaggedValue tag = EAUtil.findTaggedValue(sqlElement, ObjectVariable.BindingSemanticsTaggedValueName);
if (tag != null)
{
if (tag.Value.ToLower() == "optional")
{
result.Add("Optional ist not supported anymore");
}
}
}
return(result);
}
private string computeValidatedAttribute()
{
SQLTaggedValue validatedTag = EAUtil.findTaggedValue(package.EaPackage, MoflonValidatedTaggedValueName);
if (validatedTag != null)
{
if (validatedTag.Value.Equals(DEFAULT_VALUE_PLACEHOLDER))
{
return("false");
}
return(validatedTag.Value);
}
else
{
return("false");
}
}
private string computeExportAttribute()
{
SQLTaggedValue exportTag = EAUtil.findTaggedValue(package.EaPackage, MoflonExportTaggedValueName);
if (exportTag != null)
{
if (exportTag.Value.Equals(DEFAULT_VALUE_PLACEHOLDER))
{
return("true");
}
return(exportTag.Value);
}
else
{
return("true");
}
}
public Boolean isIgnored()
{
Object taggedObject = getObjectToBeTagged();
if (taggedObject is EA.Element)
{
EA.TaggedValue taggedValue = EAUtil.findTaggedValue(taggedObject as EA.Element, IGNORED_TAG_NAME);
if (taggedValue != null && "true".Equals(taggedValue.Value))
{
return(true);
}
}
else if (taggedObject is SQLElement)
{
return(isIgnored(taggedObject as SQLElement));
}
return(false);
}
public override void doEaGuiStuff()
{
base.doEaGuiStuff();
EA.Element sdmContainer = ActivityNodeEAElement.getRealElement();
if (sdmContainer.Stereotype == SDMModelingMain.SdmContainerStereotype)
{
try
{
SQLMethod associatedMethod = Repository.GetMethodByGuid(EAUtil.findTaggedValue(ActivityNodeEAElement, SDMModelingMain.SDMContainerAssociatedMethodTaggedValueName).Value);
SQLElement containingEClass = Repository.GetElementByID(associatedMethod.ParentID);
ActivityNodeEAElement.getRealElement().Name = SDMUtil.computeStartNodeName(associatedMethod, containingEClass);
}
catch (Exception)
{
}
}
sdmContainer.StereotypeEx = SDMModelingMain.StartNodeStereotype;
sdmContainer.Update();
}
public override List <String> doRule(SQLElement eaElement, SQLWrapperClasses.SQLRepository repository)
{
List <String> results = new List <string>();
if (eaElement.Stereotype == TGGModelingMain.TggObjectVariableStereotype || eaElement.Stereotype == TGGModelingMain.TggCorrespondenceStereotype)
{
ObjectVariable tggOv = ObjectVariable.createCorrectOvType(eaElement, repository);
tggOv.loadTreeFromTaggedValue();
if (tggOv.BindingOperator == Modeling.SDMModeling.SDMExportWrapper.patterns.BindingOperator.CREATE && tggOv.Constraints.Count > 0)
{
results.Add("Constraints and BindingOperator create is not allowed");
}
else if (tggOv.BindingOperator == Modeling.SDMModeling.SDMExportWrapper.patterns.BindingOperator.CHECK_ONLY && tggOv.AttributeAssignments.Count > 0)
{
results.Add("AttributeAssigmnments and BindingOperator check_only is not allowed");
}
else if (tggOv.BindingState == Modeling.SDMModeling.SDMExportWrapper.patterns.BindingState.BOUND)
{
Boolean valid = false;
foreach (SQLConnector con in eaElement.Connectors)
{
if (con.SupplierID == eaElement.ElementID && con.Type == Main.EADependencyType)
{
valid = true;
}
}
if (!valid)
{
SQLTaggedValue refinedtag = EAUtil.findTaggedValue(eaElement, TGGObjectVariable.RefinedTaggedValueName);
if (refinedtag == null || refinedtag.Value == "false")
{
results.Add("Bound TGG ObjectVariables must be the target of a TGG BindingExpression");
}
}
}
}
return(results);
}
public static String getIdOfReference(SQLConnector con, SQLRepository rep)
{
SQLConnectorTag idOfRefTag = EAUtil.findTaggedValue(con, "idOfReference");
if (idOfRefTag != null)
{
int possibleId = 0;
if (int.TryParse(idOfRefTag.Value, out possibleId))
{
try
{
SQLConnector refCon = rep.GetConnectorByID(possibleId);
return(refCon.ConnectorGUID);
}
catch
{
return("");
}
}
return(idOfRefTag.Value);
}
return("");
}
public SDMCSPDialog(SQLElement elem, SQLRepository sqlRepository)
{
this.InitializeComponent();
this.elem = EAUtil.sqlEAObjectToOriginalObject(sqlRepository, elem) as EA.Element;
this.sqlRepository = sqlRepository;
if (elem.Notes.Trim() == "")
{
textBoxCspDefinition.Text = DEFAULT_CSP_CONTENT;
}
else
{
textBoxCspDefinition.Text = elem.Notes;
}
SQLTaggedValue nacIndexTag = EAUtil.findTaggedValue(elem, "nacIndex");
if (nacIndexTag != null)
{
complexNAC1.setNacIndexValue(nacIndexTag.Value);
}
StartPosition = FormStartPosition.CenterScreen;
}
public void processActivityNode(SQLElement activityNodeEAElement)
{
if (Serialization.MocaTaggableElement.isIgnored(activityNodeEAElement))
{
return;
}
ActivityNode actNode = null;
if (activityNodeEAElement.Stereotype == "StoryNode" || activityNodeEAElement.Elements.Count > 0 || (activityNodeEAElement.Elements.Count == 0 && activityNodeEAElement.Notes == "" && activityNodeEAElement.Subtype != 100 && activityNodeEAElement.Subtype != 101))
{
actNode = new StoryNode(repository, activityNodeEAElement);
}
else if (activityNodeEAElement.Stereotype == "StopNode" || activityNodeEAElement.Subtype == 101)
{
actNode = new StopNode(repository, activityNodeEAElement);
}
else if (activityNodeEAElement.Stereotype == "StartNode" || activityNodeEAElement.Subtype == 100)
{
actNode = new StartNode(repository, activityNodeEAElement);
}
else if (activityNodeEAElement.Stereotype == "StatementNode" || (activityNodeEAElement.Elements.Count == 0 && activityNodeEAElement.Notes != ""))
{
actNode = new StatementNode(repository, activityNodeEAElement);
}
Boolean valid = actNode.loadTreeFromTaggedValue();
SQLTaggedValue mocaTreeTag = EAEcoreAddin.Util.EAUtil.findTaggedValue(activityNodeEAElement, Main.MoflonExportTreeTaggedValueName);
MocaNode activityNodeMocaNode = new MocaNode();
activityNodeMocaNode.deserializeFromXmlTree(MocaTreeUtil.stringToXmlDocument(mocaTreeTag.Notes).DocumentElement.FirstChild as XmlElement);
this.currentNode.appendChildNode(activityNodeMocaNode);
foreach (SQLConnector activityEdge in activityNodeEAElement.Connectors)
{
if ((activityEdge.Stereotype == SDMModelingMain.ActivityEdgeStereotype || activityEdge.Stereotype == "") && activityEdge.Type == "ControlFlow" && activityEdge.ClientID == activityNodeEAElement.ElementID)
{
this.currentNode = activityNodeMocaNode.getChildNodeWithName(ActivityNode.OutgoingTransitionsNodeName);
processActivityEdge(activityEdge);
}
}
foreach (SQLElement storyNodeChild in activityNodeEAElement.Elements)
{
if (storyNodeChild.Stereotype == SDMModelingMain.ObjectVariableStereotype || storyNodeChild.Stereotype == "SDM_Object")
{
this.currentNode = activityNodeMocaNode.getChildNodeWithName(StoryPattern.ObjectVariablesChildNodeName);
processObjectVariable(storyNodeChild);
}
else if (storyNodeChild.Stereotype == SDMModelingMain.CSPInstanceStereotype)
{
this.currentNode = activityNodeMocaNode.getChildNodeWithName("AttributeConstraints");
if (currentNode == null)
{
this.currentNode = activityNodeMocaNode.appendChildNode("AttributeConstraints");
}
MocaNode cspNode = currentNode.appendChildNode("AttributeConstraint");
cspNode.appendChildAttribute("constraintSpec", storyNodeChild.Notes);
SQLTaggedValue nacIndexTag = EAUtil.findTaggedValue(storyNodeChild, "nacIndex");
if (nacIndexTag != null)
{
String nacIndex = nacIndexTag.Value;
cspNode.appendChildAttribute("nacIndex", nacIndex != "" ? nacIndex : "-1");
}
}
}
}
private void createExtractedSDMStatementNode()
{
Boolean thisPatternCreated = false;
int leftMax = 0;
int topMax = -100000;
computeLeftAndTopMax(ref leftMax, ref topMax);
EA.Element thisObject = searchThisObject();
//only create a statementNode if there exists a this object on the sdm
//otherwise create new story node with an this variable
if (thisObject == null)
{
thisOvPattern = createStoryPattern("this Activity");
thisObject = createThisOv(thisOvPattern);
createDiagramObject(leftMax + 50, topMax - 20, 50, 100, thisObject);
createDiagramObject(leftMax, topMax, 100, 200, thisOvPattern);
thisPatternCreated = true;
leftMax += 300;
}
//create new story node with objectvariable bound to new sdm.
if (checkBoxBoundOv.Checked)
{
EA.Element boundOvPattern = createStoryPattern("Bound new SDM");
EA.Element boundObject2 = createThisOv(boundOvPattern);
SQLElement boundObject = sqlRepository.GetElementByID(boundObject2.ElementID);
createDiagramObject(leftMax + 20, topMax - 20, 50, 100, boundObject2);
createDiagramObject(leftMax, topMax, 100, 200, boundOvPattern);
ObjectVariable ov = new ObjectVariable(boundObject, sqlRepository);
ov.loadTreeFromTaggedValue();
ov.BindingState = BindingState.BOUND;
MethodCallExpression mcExp = new MethodCallExpression(sqlRepository.GetMethodByID(newMethod.MethodID), sqlRepository);
ObjectVariableExpression ovExp = new ObjectVariableExpression(sqlRepository.GetElementByID(thisObject.ElementID), sqlRepository);
mcExp.Target = ovExp;
ov.BindingExpression = mcExp;
ov.Classifier = ovClassifiersComboBox1.Classifiers[ovClassifiersComboBox1.SelectedIndex];
ov.saveTreeToEATaggedValue(true);
sdmCallPattern = boundOvPattern;
EA.Method sdmMethod = repository.GetMethodByGuid(EAUtil.findTaggedValue(sqlRepository.GetElementByID(newSdmContainer.ElementID), SDMModelingMain.SDMContainerAssociatedMethodTaggedValueName).Value);
sdmMethod.ClassifierID = "" + ov.Classifier.EaElement.ElementID;
sdmMethod.ReturnType = ov.Classifier.EaElement.Name;
sdmMethod.Update();
}
//instead create statement node construct
else
{
EA.Element statementActivity = createStoryPattern("Call extracted method");
StatementNode statementNode = new StatementNode(sqlRepository, sqlRepository.GetElementByID(statementActivity.ElementID));
MethodCallExpression mcExp = new MethodCallExpression(sqlRepository.GetMethodByID(newMethod.MethodID), sqlRepository);
ObjectVariableExpression ovExp = new ObjectVariableExpression(sqlRepository.GetElementByID(thisObject.ElementID), sqlRepository);
mcExp.Target = ovExp;
statementNode.StatementExpression = mcExp;
statementActivity.Notes = thisObject.Name + "." + newMethod.Name + "()";
EAEcoreAddin.Util.EAUtil.setTaggedValue(sqlRepository, statementActivity, "activityType", "call");
EAEcoreAddin.Util.EAUtil.setTaggedValue(sqlRepository, statementActivity, "evacuated", "false");
statementActivity.Update();
createDiagramObject(leftMax, topMax, 200, 200, statementActivity);
statementNode.saveTreeToEATaggedValue(true);
sdmCallPattern = statementActivity;
}
if (thisPatternCreated)
{
//create edge between this pattern and statement pattern
EA.Connector acEdge = thisOvPattern.Connectors.AddNew("", Main.EAControlFlowType) as EA.Connector;
acEdge.SupplierID = sdmCallPattern.ElementID;
acEdge.Update();
ActivityEdge edge = new ActivityEdge(sqlRepository, sqlRepository.GetConnectorByID(acEdge.ConnectorID));
edge.saveTreeToEATaggedValue(true);
}
}
