/// <summary>
/// Implements IForcesModel.GetDecisions()
/// </summary>
/// <returns></returns>
public IEAElement[] GetDecisions()
{
IEARepository repository = EAMain.Repository;
IEAElement[] topicsElements = (from diagramObject in _diagram.GetElements()
select repository.GetElementByID(diagramObject.ElementID)
into element
where
EAMain.IsTopic(element) &&
!element.TaggedValueExists(EATaggedValueKeys.IsForceElement, _diagram.GUID)
select element).ToArray();
ITopic[] topics = (from element in topicsElements select Topic.Load(element)).ToArray();
IEnumerable <IEAElement> decisionsFromTopic =
(from ITopic topic in topics select topic.GetDecisionsForTopic()).SelectMany(x => x);
IEnumerable <IEAElement> decisionsDirectlyFromDiagram = (from diagramObject in _diagram.GetElements()
select
repository.GetElementByID(
diagramObject.ElementID)
into element
where
element.TaggedValueExists(
EATaggedValueKeys.IsDecisionElement,
_diagram.GUID)
select element);
return(decisionsFromTopic.Union(decisionsDirectlyFromDiagram).ToArray());
}
public override bool EA_OnPreDeleteDiagram(Repository repository, EventProperties properties)
{
EAMain.UpdateRepository(repository);
IEAVolatileDiagram diagram = EAMain.WrapVolatileDiagram(properties);
return(_listeners.All(l => l.OnPreDeleteDiagram(diagram)));
}
public static void CreateAndTraceTopic()
{
IEARepository repository = EAMain.Repository;
if (repository.GetContextItemType() == EANativeType.Element)
{
var eaelement = repository.GetContextObject <IEAElement>();
if (eaelement != null && !EAMain.IsDecision(eaelement) && !EAMain.IsTopic(eaelement))
{
string nameSuggestion = string.Format(Messages.NameSuggestionTopic, eaelement.Name);
var createTopicView = new CreateTopicDialog(nameSuggestion);
if (createTopicView.ShowDialog() == DialogResult.OK)
{
IEAPackage dvPackage = createTopicView.GetDecisionViewPackage();
IEAElement topic = dvPackage.CreateElement(createTopicView.GetName(),
EAConstants.TopicStereoType,
EAConstants.ActivityMetaType);
topic.MetaType = EAConstants.TopicMetaType;
topic.AddTaggedValue(EATaggedValueKeys.DecisionStateModifiedDate,
DateTime.Now.ToString(CultureInfo.InvariantCulture));
eaelement.ConnectTo(topic, EAConstants.AbstractionMetaType, EAConstants.RelationTrace);
topic.Update();
dvPackage.RefreshElements();
repository.RefreshModelView(dvPackage.ID);
topic.ShowInProjectView();
}
}
}
}
public override string EA_OnRetrieveModelTemplate(Repository repository, string location)
{
EAMain.UpdateRepository(repository);
var resource = "DecisionArchitect.Templates." + location;
return(Utils.GetResourceContents(resource));
}
public override void EA_OnRunElementRule(Repository repository, string ruleId, Element element)
{
EAMain.UpdateRepository(repository);
IEAElement wrappedElement = EAMain.WrapElement(element);
_modelValidator.ValidateElementUsingRuleID(repository, ruleId, wrappedElement);
}
private void OnModelChangeConnectorAdded(ModelChangedEventArgs args)
{
IEAConnector connector = EAMain.Repository.GetConnectorByGUID(args.GUID);
if (connector.ClientId != Decision.ID && connector.SupplierId != Decision.ID)
{
return;
}
if (EAMain.IsDecisionRelationship(connector))
{
var related = new DecisionRelation(Decision, connector);
if (EAMain.IsAlternativeRelationship(connector))
{
Decision.Alternatives.Add(related);
}
else
{
Decision.RelatedDecisions.Add(related);
}
}
else if (EAMain.IsTrace(connector))
{
Decision.Traces.Add(new TraceLink(Decision, connector));
}
else if (EAMain.IsStakeholderAction(connector))
{
Decision.Stakeholders.Add(new StakeholderAction(Decision, connector));
}
}
/********************************************************************************************
** EAMain Callbacks
********************************************************************************************/
/// <summary>
/// This method is called when double clicking an element in the view pane. It opens the respective View.
/// </summary>
/// <param name="guid">
/// A string holding the GUID of the EAElement clicked by the user.
/// </param>
/// <param name="type">
/// The EANativeType of the element clicked by the user.
/// </param>
/// <returns></returns>
public override bool OnContextItemDoubleClicked(string guid, EANativeType type)
{
// If the type is not an Element
if (type != EANativeType.Element)
{
return(false);
}
// Get the element
IEAElement element = EAMain.Repository.GetElementByGUID(guid);
// If it is not a decision or a topic, leave!
if (!(EAMain.IsDecision(element) || EAMain.IsTopic(element)))
{
return(false);
}
// Check if the tab is already open.
if (EAMain.IsDecision(element))
{
OpenDecisionDetailView(Decision.Load(element));
return(true);
}
if (EAMain.IsTopic(element))
{
OpenTopicDetailView(Topic.Load(element));
return(true);
}
return(false);
}
public void EA_WrapElement_elementTest()
{
Element element = _e.GetDecisionPackageElement();
IEAElement e = EAMain.WrapElement(element);
Assert.IsTrue(element.ElementID == e.ID);
}
public void EA_WrapConnectorTest()
{
Connector connector = _e.GetForcesElementConnector();
IEAConnector c = EAMain.WrapConnector(connector);
Assert.IsTrue(connector.ConnectorID == c.ID);
}
public override void EA_OnRunConnectorRule(Repository repository, string ruleId, int connectorId)
{
EAMain.UpdateRepository(repository);
IEAConnector connector = EAMain.Repository.GetConnectorByID(connectorId);
_modelValidator.ValidateConectorUsingRuleID(repository, ruleId, connector);
}
public override void EA_OnNotifyContextItemModified(Repository repository, string guid, ObjectType ot)
{
EAMain.UpdateRepository(repository);
foreach (IRepositoryListener l in _listeners)
{
l.OnNotifyContextItemModified(guid, EAUtilities.Translate(ot));
}
}
public override void EA_FileNew(Repository repository)
{
EAMain.UpdateRepository(repository);
foreach (IRepositoryListener l in _listeners)
{
l.OnFileNew();
}
}
public void EA_WrapElement_eventPropertiesTest()
{
IEADiagramObject obj = _e.GetForcesDiagramObject();
EventProperties properties = EAEventPropertiesHelper.GetInstance("", "", "", 0, 0, 0, obj.ElementID, 0);
IEAElement e = EAMain.WrapElement(properties);
Assert.IsTrue(obj.ElementID == e.ID);
}
public override object EA_OnInitializeTechnologies(Repository repository)
{
EAMain.UpdateRepository(repository);
const string resource = "DecisionArchitect." + "DecisionArchitectMDG.xml";
Log.Debug($"Initialize MDG Technology {resource}");
return(Utils.GetResourceContents(resource));
}
public void EA_WrapVolatileElement_diagramTest()
{
IEADiagram diagram = _e.GetDecisionForcesDiagram();
EventProperties properties = EAEventPropertiesHelper.GetInstance("", "", "", 0, 0, diagram.ID, 0, 0);
IEAVolatileElement e = EAMain.WrapVolatileElement(properties);
Assert.IsTrue(diagram.ID == e.Diagram.ID);
}
private void LoadStakeholders()
{
_stakeholderElements =
(from x in EAMain.Repository.GetAllElements() where EAMain.IsStakeholder(x) select x).ToList();
var stakeholderNames = (from stakeholder in _stakeholderElements select stakeholder.Name).ToArray();
// ReSharper disable once CoVariantArrayConversion
cmboStakeholder.Items.AddRange(stakeholderNames);
}
/// <summary>
/// This is called if the user clicks on a tab
/// </summary>
/// <param name="repository"></param>
/// <param name="tabname">
/// tells the listeners which tab
/// </param>
/// <param name="diagramID"></param>
public override void EA_OnTabChanged(Repository repository, string tabname, int diagramID)
{
//MessageBox.Show("EA_OnTabChanged " + tabname);
EAMain.UpdateRepository(repository);
foreach (IRepositoryListener l in _listeners)
{
l.OnTabChanged(tabname, diagramID);
}
}
private static bool ContextItemAreDecisions()
{
IEnumerable <IEAElement> selectedTopicsAndDecisions =
(from IEAElement element in EAMain.Repository.GetSelectedItems()
where (EAMain.IsDecision(element) || EAMain.IsTopic(element)) && !EAMain.IsHistoryDecision(element)
select element);
return(selectedTopicsAndDecisions.Any());
}
public override void EA_OnPostOpenDiagram(Repository repository, int diagramId)
{
EAMain.UpdateRepository(repository);
IEADiagram diagram = EAMain.Repository.GetDiagramByID(diagramId);
foreach (IRepositoryListener l in _listeners)
{
l.OnPostOpenDiagram(diagram);
}
}
public void EA_WrapVolatileElement_elementTest()
{
Element element = _e.GetDecisionPackageElement();
EventProperties properties = EAEventPropertiesHelper.GetInstance(
EAConstants.EventPropertyTypeElement, element.Subtype.ToString(CultureInfo.InvariantCulture), element.Stereotype, 0, 0, 0, 0,
element.ElementID);
IEAVolatileElement e = EAMain.WrapVolatileElement(properties);
Assert.IsTrue(element.ElementID == e.ParentElement.ID);
}
private ITopic LoadTopic(IEAElement element)
{
if (element.ParentElement != null)
{
if (EAMain.IsTopic(element.ParentElement))
{
return(Model.Topic.Load(element.ParentElement));
}
}
return(null);
}
public IEnumerable <IEAElement> GetDecisionsForTopic()
{
IEAElement element = EAMain.Repository.GetElementByGUID(GUID);
if (!EAMain.IsTopic(element))
{
throw new Exception("EAElementImpl is not a topic");
}
return(from IEAElement e in element.GetElements() where EAMain.IsDecision(e) select e);
}
public static IStakeholder Load(IEAElement element)
{
if (null == element || !EAMain.IsStakeholder(element))
{
throw new ArgumentException("Argument null or not a stakeholder");
}
var stakeholder = new Stakeholder {
Name = element.Name, Role = element.Stereotype, GUID = element.GUID
};
return(stakeholder);
}
public override bool EA_OnPostNewDiagramObject(Repository repository, EventProperties properties)
{
EAMain.UpdateRepository(repository);
foreach (IRepositoryListener l in _listeners)
{
if (!l.OnPostNewDiagramObject())
{
return(false);
}
}
return(true);
}
public override bool EA_OnContextItemDoubleClicked(Repository repository, string guid, ObjectType ot)
{
EAMain.UpdateRepository(repository);
foreach (IRepositoryListener l in _listeners)
{
if (l.OnContextItemDoubleClicked(guid, EAUtilities.Translate(ot)))
{
return(true);
}
}
return(false);
}
private void LoadStakeholder(IEAElement element)
{
Stakeholders.Clear();
IEnumerable <IStakeholderAction> actions =
element.GetConnectors()
.Where(connector => connector.IsAction() && EAMain.IsStakeholder(connector.GetClient()))
.Select(sa => (IStakeholderAction) new StakeholderAction(this, sa));
foreach (IStakeholderAction action in actions)
{
Stakeholders.Add(action);
}
}
public override bool OnPostNewElement(IEAElement element)
{
if (EAMain.IsDecision(element))
{
element.AddTaggedValue(EATaggedValueKeys.DecisionState, element.Stereotype);
element.AddTaggedValue(EATaggedValueKeys.IsHistoryDecision, false.ToString());
}
if (EAMain.IsDecision(element) || EAMain.IsTopic(element))
{
element.AddTaggedValue(EATaggedValueKeys.DecisionStateModifiedDate,
element.Modified.ToString(CultureInfo.InvariantCulture));
}
return(true);
}
public void EA_WrapVolatileConnectorTest()
{
Connector connector = _e.GetForcesElementConnector();
EventProperties properties = EAEventPropertiesHelper.GetInstance(
connector.Type, connector.Subtype, connector.Stereotype, connector.ClientID, connector.SupplierID,
connector.DiagramID, 0, 0);
IEAVolatileConnector c = EAMain.WrapVolatileConnector(properties);
Assert.IsTrue(connector.Type == c.Type);
Assert.IsTrue(connector.Subtype == c.Subtype);
Assert.IsTrue(connector.ClientID == c.Client.ID);
Assert.IsTrue(connector.SupplierID == c.Supplier.ID);
Assert.IsNull(c.Diagram); // Connector diagram ID is zero
}
public override bool EA_OnPreNewConnector(Repository repository, EventProperties info)
{
EAMain.UpdateRepository(repository);
IEAVolatileConnector volatileConnector = EAMain.WrapVolatileConnector(info);
foreach (IRepositoryListener l in _listeners)
{
if (!l.OnPreNewConnector(volatileConnector))
{
return(false);
}
}
return(true);
}
public override bool EA_OnPostNewElement(Repository repository, EventProperties properties)
{
EAMain.UpdateRepository(repository);
IEAElement element = EAMain.WrapElement(properties);
foreach (IRepositoryListener l in _listeners)
{
if (!l.OnPostNewElement(element))
{
return(false);
}
}
return(true);
}
