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));
            }
        }
示例#2
0
        public void EA_WrapConnectorTest()
        {
            Connector    connector = _e.GetForcesElementConnector();
            IEAConnector c         = EAMain.WrapConnector(connector);

            Assert.IsTrue(connector.ConnectorID == c.ID);
        }
示例#3
0
        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);
        }
示例#4
0
        /// <summary>
        /// Add a new force for each concern if the combination not exists already
        /// </summary>
        /// <param name="force"></param>
        private void AddForceConcerns(IEAElement force)
        {
            IEARepository repository  = EAFacade.EA.Repository;
            string        diagramGuid = _controller.Model.DiagramGUID;
            IEADiagram    diagram     = repository.GetDiagramByGuid(diagramGuid);

            //Add the force for each selected concern
            foreach (var item in _lbConcern.SelectedItems)
            {
                var        selectedItem = (KeyValuePair <string, string>)item;
                IEAElement concern      = repository.GetElementByGUID(selectedItem.Key);

                diagram.AddElement(concern);

                IEAConnector connector = force.ConnectTo(concern, EAConstants.ForcesConnectorType, EAConstants.RelationClassifiedBy);
                if (!connector.TaggedValueExists(EATaggedValueKeys.IsForceConnector, diagramGuid))
                {
                    // Add TaggedValue for new force and concern (having multiple TaggedValues of the same name/data is possible).
                    // The amount of TaggedValues with the same name and data is the amount of forces/concerns in the table.
                    force.AddTaggedValue(EATaggedValueKeys.IsForceElement, diagramGuid);
                    concern.AddTaggedValue(EATaggedValueKeys.IsConcernElement, diagramGuid);

                    // Add the diagramGuid as a TaggedValue (ConnectorTag) to the connector
                    connector.AddTaggedValue(EATaggedValueKeys.IsForceConnector, diagramGuid);
                    _closeWindow = true;
                }
                else //Force concern combination (connector) already exists
                {
                    MessageBox.Show(string.Format(Messages.ForcesViewForceExists, force.Name, concern.Name),
                                    "Force already exists", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }
        }
示例#5
0
        private void SaveTraces(IEAElement element)
        {
            //first need to identify those tracelinks that were removed and those that were added
            // currently traces do not support update and can only be added or removed
            IEAElement[] existingTraces = element.GetTracedElements().ToArray();
            // existing.except(traces) traces that have been deleted
            IEnumerable <string> removedTraces =
                existingTraces.Select(e => e.GUID).Except(Traces.Select(t => t.TracedElementGUID));

            // traces.except(existing) traces that were added
            IEnumerable <string> addedTraces =
                Traces.Select(t => t.TracedElementGUID).Except(existingTraces.Select(e => e.GUID));

            //in order to remove tracelink i need to find the correct connection that connect this and the linked element.
            foreach (string removedTrace in removedTraces)
            {
                IEAConnector connector =
                    element.GetConnectors().FirstOrDefault(c => (c.GetSupplier().GUID.Equals(removedTrace) ||
                                                                 c.GetClient().GUID.Equals(removedTrace))
                                                           &&
                                                           c.Stereotype.Equals(EAConstants.RelationTrace) &&
                                                           c.Type.Equals(EAConstants.AbstractionMetaType));
                if (null != connector)
                {
                    element.RemoveConnector(connector);
                }
            }

            foreach (string addedTrace in addedTraces)
            {
                IEAElement suppliedElement = EAMain.Repository.GetElementByGUID(addedTrace);
                element.ConnectTo(suppliedElement, EAConstants.AbstractionMetaType, EAConstants.RelationTrace);
            }
        }
 public override bool ValidateConnector(IEAConnector connector)
 {
     if (connector.SupplierId == connector.ClientId)
     {
         return(false);
     }
     return(true);
 }
示例#7
0
 public StakeholderAction(IDecision decision, IEAConnector connector)
 {
     Stakeholder      = Model.Stakeholder.Load(connector.GetClient());
     Action           = connector.Stereotype;
     ConnectorGUID    = connector.GUID;
     Decision         = decision;
     PropertyChanged += OnPropertyChanged;
 }
        public TraceLink(IDecision decision, IEAConnector connector)
        {
            IEAElement tracedElement = (connector.ClientId == decision.ID)
                                           ? connector.GetSupplier()
                                           : connector.GetClient();

            TracedElementGUID = tracedElement.GUID;
            TracedElementName = tracedElement.Name;
            ConnectorGUID     = connector.GUID;
        }
示例#9
0
        public IEAConnector GetChronologyDecisionConnector()
        {
            IEAElement          decision   = GetChronologyDecisionElement();
            List <IEAConnector> connectors = decision.GetConnectors();

            Assert.IsTrue(connectors.Any());
            IEAConnector connect = connectors.ElementAt(0);

            return(connect);
        }
示例#10
0
        public IEAConnector GetStakeholderDecisionConnector()
        {
            IEAElement          decision   = GetStakeholderActorElement();
            List <IEAConnector> connectors = decision.GetConnectors();

            Assert.IsTrue(connectors.Any());
            IEAConnector connect = connectors.ElementAt(0);

            return(connect);
        }
示例#11
0
 public override bool OnPreDeleteConnector(IEAConnector connector)
 {
     OnModelChanged(new ModelChangedEventArgs
     {
         GUID       = connector.GUID,
         Type       = ModelChangedType.RemovedConnector,
         NativeType = EANativeType.Connector
     });
     return(true);
 }
示例#12
0
        public DecisionRelation(IDecision decision, IEAConnector eaConnector)
        {
            IEAElement client = eaConnector.GetClient();

            Direction = client.GUID.Equals(decision.GUID)
                            ? DecisionRelationDirection.Incoming
                            : DecisionRelationDirection.Outgoing;

            Decision     = decision;
            RelationGUID = eaConnector.GUID;
            Type         = eaConnector.Stereotype;
        }
        public override void OnNotifyContextItemModified(string guid, EANativeType ot)
        {
            string message;

            switch (ot)
            {
            case EANativeType.Element:

                IEAElement element = EAMain.Repository.GetElementByGUID(guid);

                //dirty hack to prevent that the event is fired twice when an decision is modified
                if (_lastGUID.Equals(guid) && _lastChange.Equals(element.Modified))
                {
                    return;
                }

                if (!RuleManager.Instance.ValidateElement(element, out message))
                {
                    MessageBox.Show(
                        message,
                        Messages.WarningCreateRelation,
                        MessageBoxButtons.OK,
                        MessageBoxIcon.Exclamation,
                        MessageBoxDefaultButton.Button1);
                }
                _lastGUID   = guid;
                _lastChange = element.Modified;

                break;

            case EANativeType.Connector:
                IEAConnector connector = EAMain.Repository.GetConnectorByGUID(guid);

                //dirty hack that prevents that an modified event is fired after a connector has been created
                if (_preventConnectorModifiedEvent)
                {
                    _preventConnectorModifiedEvent = false;
                }
                else
                {
                    if (!RuleManager.Instance.ValidateConnector(connector, out message))
                    {
                        MessageBox.Show(
                            message,
                            Messages.WarningCreateRelation,
                            MessageBoxButtons.OK,
                            MessageBoxIcon.Exclamation,
                            MessageBoxDefaultButton.Button1);
                    }
                }
                break;
            }
        }
示例#14
0
        public void EA_ConnectorTests()
        {
            // Properties

            {
                IEAConnector connect = _e.GetForcesDecisionConnector();
                Assert.IsTrue("ControlFlow" == connect.Type);
                Assert.IsTrue(EAConstants.RelationAlternativeFor == connect.Stereotype);
                Assert.IsTrue(0 < connect.SupplierId);
                Assert.IsTrue(0 < connect.ClientId);
                Assert.IsTrue(EAConstants.RelationMetaType == connect.MetaType);
                List <IEAConnectorTag> tags = connect.TaggedValues;
                Assert.IsTrue(!tags.Any());
            }

            // Operations

            {
                // GetSupplier / GetClient
                IEAConnector connect  = _e.GetForcesDecisionConnector();
                IEAElement   supplier = connect.GetSupplier();
                Assert.IsNotNull(supplier);
                Assert.IsTrue(connect.SupplierId == supplier.ID);
                IEAElement client = connect.GetClient();
                Assert.IsNotNull(client);
                Assert.IsTrue(connect.ClientId == client.ID);
            }

            /* TODO: adjust for Decision Architect MDG
             * {  // IsRelationship
             *  IEAConnector connect = _e.GetRelationshipDecisionConnector();
             *  Assert.IsTrue(connect.IsRelationship());
             * }
             *
             * {  // IsAction
             *  IEAConnector connect = _e.GetStakeholderDecisionConnector();
             *  Assert.IsTrue(connect.IsAction());
             * }
             *
             * {  // AddTaggedValue / TaggedValueExists / RemoveTaggedValue
             *  string taggedValueLabel = "MyTaggedValue";
             *  string taggedValueData = "my data";
             *  IEAConnector connect = _e.GetChronologyDecisionConnector();
             *  Assert.IsFalse(connect.TaggedValueExists(taggedValueLabel));
             *  connect.AddTaggedValue(taggedValueLabel, taggedValueData);
             *  Assert.IsTrue(connect.TaggedValueExists(taggedValueLabel));
             *  Assert.IsTrue(connect.TaggedValueExists(taggedValueLabel, taggedValueData));
             *  connect.RemoveTaggedValue(taggedValueLabel, taggedValueData);
             *  Assert.IsFalse(connect.TaggedValueExists(taggedValueLabel));
             * }
             */
        }
示例#15
0
 public override bool ValidateConnector(IEAConnector connector)
 {
     if (_relationType.Count == 0 || _relationType.Contains(connector.Stereotype))
     {
         if (_clientState.Count == 0 || _clientState.Contains(connector.GetClient().Stereotype))
         {
             if (_supplierState.Count == 0 ||
                 _supplierState.Contains(connector.GetSupplier().Stereotype))
             {
                 return(false);
             }
         }
     }
     return(true);
 }
示例#16
0
        /// <summary>
        ///     Implements IEAElement.RemoveConnector(IEAConnector connector)
        /// </summary>
        /// <param name="connector"></param>
        public void RemoveConnector(IEAConnector connector)
        {
            for (short i = 0; i < _native.Connectors.Count; i++)
            {
                EAConnector con = EAConnector.Wrap(_native.Connectors.GetAt(i));

                if (!con.GUID.Equals(connector.GUID))
                {
                    continue;
                }
                _native.Connectors.Delete(i);
                _native.Connectors.Refresh();
                _native.Update();
                return;
            }
        }
示例#17
0
        private void OnModelChangeConnectorRemoved(ModelChangedEventArgs args)
        {
            IEAConnector connector = EAMain.Repository.GetConnectorByGUID(args.GUID);

            if (EAMain.IsDecisionRelationship(connector))
            {
                foreach (IDecisionRelation related in Decision.RelatedDecisions.ToArray())
                {
                    if (related.RelationGUID.Equals(args.GUID))
                    {
                        Decision.RelatedDecisions.Remove(related);
                        return;
                    }
                }
                foreach (IDecisionRelation related in Decision.Alternatives.ToArray())
                {
                    if (related.RelationGUID.Equals(args.GUID))
                    {
                        Decision.Alternatives.Remove(related);
                        return;
                    }
                }
            }
            else if (EAMain.IsTrace(connector))
            {
                foreach (ITraceLink trace in Decision.Traces.ToArray())
                {
                    if (trace.ConnectorGUID.Equals(args.GUID))
                    {
                        Decision.Traces.Remove(trace);
                        return;
                    }
                }
            }
            else if (EAMain.IsStakeholderAction(connector))
            {
                foreach (IStakeholderAction action in Decision.Stakeholders.ToArray())
                {
                    if (action.ConnectorGUID.Equals(args.GUID))
                    {
                        Decision.Stakeholders.Remove(action);
                        return;
                    }
                }
            }
        }
        public bool ValidateConnector(IEAConnector connector, out string message)
        {
            message = "";

            if (!EAConstants.Relationships.Contains(connector.Stereotype))
            {
                return(true);
            }

            foreach (AbstractRule rule in _rules.Where(r => r.GetRuleType() == RuleType.Connector))
            {
                if (!rule.Validate(connector, out message))
                {
                    return(false);
                }
            }
            return(true);
        }
示例#19
0
        public override bool EA_OnPreDeleteConnector(Repository repository, EventProperties properties)
        {
            EAMain.UpdateRepository(repository);
            int connectorID;

            if (Int32.TryParse(properties.Get(EAEventPropertyKeys.ConnectorID).Value, out connectorID))
            {
                IEAConnector connector = EAMain.Repository.GetConnectorByID(connectorID);
                foreach (IRepositoryListener l in _listeners)
                {
                    if (!l.OnPreDeleteConnector(connector))
                    {
                        return(false);
                    }
                }
            }
            return(true);
        }
示例#20
0
        private bool DeleteForce(IEAElement topicElement, IEAConnector connector)
        {
            //first remove the connection between topic-> force
            topicElement.RemoveConnector(connector);
            var forceElement = Force.Element;

            //now all connectionsb etween force->decision
            foreach (var decisionEvaluation in DecisionEvaluations)
            {
                decisionEvaluation.Delete(forceElement);
            }

            //finally between force->concern
            var concernConnector = (from x in forceElement.GetConnectors()
                                    where
                                    x.GetSupplier().GUID.Equals(Concern.ConcernGUID) && x.TaggedValueExists(EAConstants.ConcernUID) &&
                                    x.GetTaggedValueByName(EAConstants.ConcernUID).Equals(Concern.UID)
                                    select x).FirstOrDefault();

            forceElement.RemoveConnector(concernConnector);

            return(true);
        }
        public void ValidateConectorUsingRuleID(Repository repository, string ruleID, IEAConnector connector)
        {
            Project      project = repository.GetProjectInterface();
            AbstractRule rule    = _lookup[ruleID];

            if (rule != null && rule.GetRuleType() == RuleType.Connector)
            {
                string message;
                if (!rule.Validate(connector, out message))
                {
                    string supplierStereotype = connector.GetSupplier().Stereotype;
                    string clientStereotype   = connector.GetClient().Stereotype;
                    string errorMessage       = string.Format(Messages.ModelValidationConnectorMessage, message,
                                                              clientStereotype,
                                                              supplierStereotype, connector.Stereotype);
                    project.PublishResult(ruleID, EnumMVErrorType.mvError, errorMessage);
                }
            }
        }
        public void EA_ElementTests()
        {
            // Properties
            {
                Element element = _e.GetDecisionPackageElement();
                Assert.IsTrue("" != element.Abstract);
                Assert.IsTrue("" == element.ActionFlags);
                Assert.IsTrue("" == element.Alias);
                Assert.IsTrue(0 == element.AssociationClassConnectorID);
                Assert.IsTrue(0 == element.Attributes.Count);
                Assert.IsTrue(0 == element.AttributesEx.Count);
                Assert.IsTrue("" != element.Author);
                Assert.IsTrue(0 == element.BaseClasses.Count);
                Assert.IsTrue(0 == element.ClassfierID);
                Assert.IsTrue(0 == element.ClassifierID);
                Assert.IsTrue("" == element.ClassifierName);
                Assert.IsTrue("" == element.ClassifierType);
                Assert.IsTrue("" != element.Complexity);
                Assert.IsNull(element.CompositeDiagram);
                Assert.IsTrue(0 < element.Connectors.Count);
                Assert.IsTrue(0 == element.Constraints.Count);
                Assert.IsTrue(0 == element.ConstraintsEx.Count);
                Assert.IsTrue(DateTime.Now > element.Created);
                Assert.IsTrue(0 < element.CustomProperties.Count);
                Assert.IsTrue(0 < element.Diagrams.Count);
                Assert.IsTrue("" == element.Difficulty);
                Assert.IsTrue(0 == element.Efforts.Count);
                Assert.IsTrue("" != element.ElementGUID);
                Assert.IsTrue(0 < element.ElementID);
                Assert.IsTrue(0 < element.Elements.Count);
                Assert.IsTrue(0 == element.EmbeddedElements.Count);
                Assert.IsTrue("" == element.EventFlags);
                Assert.IsTrue("" == element.ExtensionPoints);
                Assert.IsTrue(0 == element.Files.Count);
                Assert.IsTrue("" == element.Genfile);
                Assert.IsTrue("" == element.Genlinks);
                Assert.IsTrue("" != element.Gentype);
                Assert.IsTrue("" == element.Header1);
                Assert.IsTrue("" == element.Header2);
                Assert.IsFalse(element.IsActive);
                Assert.IsFalse(element.IsComposite);
                Assert.IsFalse(element.IsLeaf);
                Assert.IsTrue(element.IsNew);
                Assert.IsFalse(element.IsSpec);
                Assert.IsTrue(0 == element.Issues.Count);
                Assert.IsFalse(element.Locked);
                Assert.IsTrue("" != element.MetaType);
                Assert.IsTrue(0 == element.Methods.Count);
                Assert.IsTrue(0 == element.MethodsEx.Count);
                Assert.IsTrue(0 == element.Metrics.Count);
                Assert.IsTrue("" == element.MiscData[0]);
                Assert.IsTrue(DateTime.Now > element.Modified);
                Assert.IsTrue("" == element.Multiplicity);
                Assert.IsTrue("" != element.Name);
                Assert.IsTrue("" == element.Notes);
                Assert.IsTrue(ObjectType.otElement == element.ObjectType);
                Assert.IsTrue(0 < element.PackageID);
                Assert.IsTrue(0 == element.ParentID);
                Assert.IsTrue(0 == element.Partitions.Count);
                Assert.IsTrue("" == element.Persistence);
                Assert.IsTrue("" != element.Phase);
                Assert.IsTrue("" == element.Priority);
                Assert.IsNotNull(element.Properties);
                Assert.IsTrue(0 == element.PropertyType);
                Assert.IsTrue(0 == element.Realizes.Count);
                Assert.IsTrue(0 == element.Requirements.Count);
                Assert.IsTrue(0 == element.RequirementsEx.Count);
                Assert.IsTrue(0 == element.Resources.Count);
                Assert.IsTrue(0 == element.Risks.Count);
                Assert.IsTrue("" == element.RunState);
                Assert.IsTrue(0 == element.Scenarios.Count);
                Assert.IsTrue(0 == element.StateTransitions.Count);
                Assert.IsTrue("" != element.Status);
                Assert.IsTrue("" != element.Stereotype);
                Assert.IsTrue("" != element.StereotypeEx);
                Assert.IsTrue("" == element.StyleEx);
                Assert.IsTrue(0 == element.Subtype);
                Assert.IsTrue("" == element.Tablespace);
                Assert.IsTrue("" == element.Tag);
                Assert.IsTrue(0 < element.TaggedValues.Count);
                Assert.IsTrue(0 < element.TaggedValuesEx.Count);
                Assert.IsTrue(0 == element.Tests.Count);
                Assert.IsTrue(1 == element.TreePos);
                Assert.IsTrue("" != element.Type);
                Assert.IsTrue("" != element.Version);
                Assert.IsTrue("" != element.Visibility);
            }

            // Operations

            {
                // GetTracedElements (no traced elements in example model)
                IEAElement element = _e.GetForcesDecisionElement();
                IEnumerable <IEAElement> elements = element.GetTracedElements();
                Assert.IsTrue(!elements.Any());
            }

            {
                // GetDiagrams
                IEAElement   element  = _e.GetForcesDecisionElement();
                IEADiagram[] diagrams = element.GetDiagrams();
                Assert.IsTrue(diagrams.Any());
            }

            {
                // GetConnectors / ConnectTo / Update / Refresh / FindConnectors / RemoveConnector
                IEAElement          element     = _e.GetForcesDecisionElement();
                const string        myType      = "Dependency";
                const string        mySterotype = "my stereotype";
                List <IEAConnector> connectors  = element.GetConnectors();
                Assert.IsTrue(connectors.Any());
                IEAConnector c      = connectors.ElementAt(0);
                IEAElement   client = c.GetClient();
                IEAConnector nc     = client.ConnectTo(element, myType, mySterotype);
                Assert.IsTrue(element.Update());
                element.Refresh();
                IList <IEAConnector> flows = client.FindConnectors(element, mySterotype, myType);
                Assert.IsNotNull(flows);
                Assert.IsTrue(flows.Any());
                element.RemoveConnector(nc);
                Assert.IsTrue(element.Update());
                element.Refresh();
                flows = client.FindConnectors(element, mySterotype, myType);
                Assert.IsNotNull(flows);
                Assert.IsFalse(flows.Any());
            }

            /* Disabled pending better understanding of Chronological view
             * {  // GetElements
             *  IEAElement element = _e.GetChronologyTopicElement();
             *  List<IEAElement> children = element.GetElements();
             *  Assert.IsTrue(0 < children.Count());
             * }
             *
             * {  // AddTaggedValue / TaggedValueExists / GetTaggedValue / RemoveTaggedValue
             *  string taggedValueLabel = "MyTaggedValue";
             *  string taggedValueData = "my data";
             *  IEAElement element = _e.GetChronologyDecisionElement();
             *  Assert.IsFalse(element.TaggedValueExists(taggedValueLabel));
             *  element.AddTaggedValue(taggedValueLabel, taggedValueData);
             *  Assert.IsTrue(element.TaggedValueExists(taggedValueLabel));
             *  Assert.IsTrue(element.TaggedValueExists(taggedValueLabel, taggedValueData));
             *  string myData = element.GetTaggedValueByName(taggedValueLabel);
             *  Assert.IsTrue(myData == taggedValueData);
             *  element.RemoveTaggedValue(taggedValueLabel, taggedValueData);
             *  Assert.IsFalse(element.TaggedValueExists(taggedValueLabel));
             * }
             */
        }
 public new abstract bool ValidateConnector(IEAConnector connector);
示例#24
0
 public static bool IsAlternativeRelationship(IEAConnector connector)
 {
     return(EAConstants.RelationAlternativeFor.Equals(connector.Stereotype));
 }
示例#25
0
 public static bool IsDecisionRelationship(IEAConnector connector)
 {
     return(EAConstants.Relationships.Contains(connector.Stereotype));
 }
示例#26
0
 public static bool IsStakeholderAction(IEAConnector connector)
 {
     return(connector.IsAction() && IsStakeholder(connector.GetClient()));
 }
示例#27
0
 public static bool IsTrace(IEAConnector connector)
 {
     return(EAConstants.RelationTrace.Equals(connector.Stereotype));
 }
示例#28
0
 public virtual bool OnPostNewConnector(IEAConnector connector)
 {
     return(true);
 }
示例#29
0
 public virtual bool OnPreDeleteConnector(IEAConnector connector)
 {
     return(true);
 }
示例#30
0
 /// <summary>
 ///     Checks if the connector is meant to be a connector in the diagram with GUID diagramGUID
 /// </summary>
 /// <param name="connector"></param>
 /// <param name="diagramGuid"></param>
 /// <returns></returns>
 private bool inDiagram(IEAConnector connector, string diagramGuid)
 {
     return
         (connector.TaggedValues.Any(
              x => x.Name.Equals(EATaggedValueKeys.IsForceConnector) && x.Value.Equals(diagramGuid)));
 }