private bool IsRelationshipValid([NotNull] IModelRelationship relationship) { var sourceNode = GetNode(relationship.Source); var targetNode = GetNode(relationship.Target); return(_modelRuleProviders?.All(i => i.IsRelationshipTypeValid(relationship.Stereotype, sourceNode, targetNode)) == true); }
///------------------------------------------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="AddRelationshipCommand" /> class. /// </summary> /// <param name="relationship"> /// The relationship. /// </param> /// <param name="version"> /// (Optional) the version. /// </param> ///------------------------------------------------------------------------------------------------- internal AddRelationshipCommand(IModelRelationship relationship, long?version = null) : this(relationship.SchemaInfo as ISchemaRelationship, relationship.Start, relationship.End, relationship.Id, version) { Contract.Requires(relationship, "relationship"); _element = relationship; }
protected static bool DiagramConnectorWouldBeRedundant(IModelRelationship modelRelationship, IDiagram diagram) { return(diagram.PathExists( diagram.TryGetNode(modelRelationship.Source).Select(i => i.Id), diagram.TryGetNode(modelRelationship.Target).Select(i => i.Id), modelRelationship.Stereotype)); }
///------------------------------------------------------------------------------------------------- /// <summary> /// Initializes a new instance of the <see cref="RemoveRelationshipCommand" /> class. /// </summary> /// <param name="relationship"> /// The relationship. /// </param> /// <param name="version"> /// (Optional) the version. /// </param> ///------------------------------------------------------------------------------------------------- public RemoveRelationshipCommand(IModelRelationship relationship, long?version = null) : base(relationship.DomainModel, version) { Contract.Requires(relationship, "relationship"); Relationship = relationship; _startId = Relationship.Start.Id; }
private static bool IsMatchPropertyName(IModelRelationship relationship, string propertyName) { // TODO a reprendre completement pour utiliser // relationship.SchemaRelationship.StartPropertyName ou end var name = relationship.Id.Key; if (String.Compare(name, propertyName, StringComparison.Ordinal) == 0) { return(true); } var sourceName = Types.SplitFullName(relationship.Start.Id.Key).Item2; if (name.StartsWith(sourceName, StringComparison.Ordinal)) { name = name.Substring(sourceName.Length); var cases = new[] { "Has" + propertyName, "References" + propertyName, propertyName }; if (cases.Any(c => String.Compare(name, c, StringComparison.Ordinal) == 0)) { return(true); } } return(false); }
// Création d'une référence 0..1 à partir de l'élément courant ou vers l'élement courant si opposite vaut true internal void SetReference(ref Identity relationshipId, ISchemaRelationship relationshipSchema, IModelElement target, bool opposite) { DebugContract.Requires(relationshipSchema, "relationshipMetadata"); using (var session = EnsuresRunInSession()) { var commands = new List <IDomainCommand>(); IModelRelationship relationship = null; // !opposite ? this -> target : target -> this IModelElement start = !opposite ? this : null; IModelElement end = !opposite ? null : this; // Si l'identifiant est fourni c'est que la relation existe surement dèjà if (relationshipId != null) { relationship = DomainModel.GetRelationship(relationshipId); } if (relationship == null) { relationship = DomainModel.GetRelationships(relationshipSchema, start, end).FirstOrDefault(); } start = !opposite ? this : target; end = !opposite ? target : this; // Si cette relation existe dèjà mais sur un autre élement, on la supprime if (relationship != null) { // Si elle existe sur le même élement, c'est bon on la conserve if (end != null && relationship.End.Id == end.Id && start != null && relationship.Start.Id == start.Id) { relationshipId = relationship.Id; return; } // Suppression car elle pointe sur un élement diffèrent commands.Add(new RemoveRelationshipCommand(relationship)); } relationship = null; relationshipId = null; // Si elle n'a pas été mise à null if (end != null && start != null) { relationshipId = DomainModel.IdGenerator.NextValue(relationshipSchema); commands.Add(new AddRelationshipCommand(relationshipSchema, start, end, relationshipId)); } Session.Current.Execute(commands.ToArray()); if (session != null) { session.AcceptChanges(); } } }
public void AddRelationship(IModelRelationship relationship) { lock (ModelUpdateLockObject) { Model = Model.AddRelationship(relationship); ModelChanged?.Invoke(new ModelRelationshipAddedEvent(Model, relationship)); } }
public DiagramConnector( IModelRelationship relationship, ModelNodeId source, ModelNodeId target, ConnectorType connectorType) : this(relationship, source, target, connectorType, Route.Empty) { }
private IEnumerable <ModelEventBase> AddRelationshipCore([NotNull] IModelRelationship relationship) { lock (ModelUpdateLockObject) { Model = Model.AddRelationship(relationship); yield return(new ModelRelationshipAddedEvent(Model, relationship)); } }
private static IModelGraph AddRelationshipCore( [NotNull] IModelRelationship relationship, [NotNull] IModelGraph modelGraph, [NotNull][ItemNotNull] ICollection <ModelItemEventBase> itemEvents) { itemEvents.Add(new ModelRelationshipAddedEvent(relationship)); return(modelGraph.AddEdge(relationship)); }
protected void AddDiagramConnectorIfNotExists(IModelRelationship modelRelationship, IDiagram diagram) { if (diagram.ConnectorExists(modelRelationship.Id)) { return; } DiagramService.AddConnector(modelRelationship.Id); }
private bool IsSymbolPairMatchingRelationship(RelatedSymbolPair symbolPair, [NotNull] IModelRelationship relationship) { var sourceNode = LatestModel.TryGetNode(relationship.Source).Value; var targetNode = LatestModel.TryGetNode(relationship.Target).Value; return(relationship.Stereotype == symbolPair.Stereotype && _symbolEqualityComparer.Equals((ISymbol)sourceNode.Payload, symbolPair.SourceSymbol) && _symbolEqualityComparer.Equals((ISymbol)targetNode.Payload, symbolPair.TargetSymbol)); }
public DiagramConnector(IModelRelationship relationship, IDiagramNode source, IDiagramNode target, ConnectorType connectorType, Route route) { ModelRelationship = relationship ?? throw new ArgumentNullException(nameof(relationship)); Source = source ?? throw new ArgumentNullException(nameof(source)); Target = target ?? throw new ArgumentNullException(nameof(target)); ConnectorType = connectorType ?? throw new ArgumentNullException(nameof(connectorType)); Route = route; }
public DiagramConnector( [NotNull] IModelRelationship relationship, ConnectorType connectorType, Route route) { ModelRelationship = relationship; ConnectorType = connectorType; Route = route; }
private void ShowContainment([NotNull] IModelRelationship addedRelationship) { var diagram = DiagramService.LatestDiagram; if (diagram.NodeExists(addedRelationship.Source) && diagram.NodeExists(addedRelationship.Target)) { DiagramService.UpdateParent(addedRelationship.Target, addedRelationship.Source); } }
private void RemoveDiagramConnector(IModelRelationship modelRelationship) { var edgeRemoved = _graph.RemoveEdge(i => i.ModelRelationship.Equals(modelRelationship)); if (edgeRemoved) { ShowModelRelationshipsIfBothEndsAreVisible(modelRelationship.Source); ShowModelRelationshipsIfBothEndsAreVisible(modelRelationship.Target); } }
private IEnumerable <ModelEventBase> AddRelationshipCore([NotNull] IModelRelationship relationship) { if (!IsRelationshipValid(relationship)) { throw new ArgumentException($"{relationship} is invalid."); } LatestModel = LatestModel.AddRelationship(relationship); yield return(new ModelRelationshipAddedEvent(LatestModel, relationship)); }
protected static bool DiagramConnectorWouldBeRedundant(IModelRelationship modelRelationship, IDiagram diagram) { if (diagram.TryGetNode(modelRelationship.Source.Id, out IDiagramNode sourceNode) && diagram.TryGetNode(modelRelationship.Target.Id, out IDiagramNode targetNode)) { return(diagram.PathExists(sourceNode.Id, targetNode.Id)); } return(false); }
protected void AddDiagramConnectorIfNotExists(IModelRelationship modelRelationship, IDiagram diagram) { if (diagram.ConnectorExists(modelRelationship.Id)) { return; } // TODO //DiagramService.ShowModelRelationship(modelRelationship); }
private bool DiagramConnectorWouldBeRedundant(IModelRelationship modelRelationship) { lock (_graph.SyncRoot) { var sourceNode = FindDiagramNode(modelRelationship.Source); var targetNode = FindDiagramNode(modelRelationship.Target); var paths = _graph.GetShortestPaths(sourceNode, targetNode, 1).ToList(); return(paths.Any()); } }
private DiagramConnector CreateDiagramConnector(IModelRelationship relationship) { var sourceNode = FindDiagramNode(relationship.Source); var targetNode = FindDiagramNode(relationship.Target); var diagramConnector = new DiagramConnector(relationship, sourceNode, targetNode); diagramConnector.RouteChanged += OnDiagramConnectorRouteChanged; return(diagramConnector); }
public static void ShouldMatch( [NotNull] this IModelRelationship relationship, ModelNodeId expectedSourceId, ModelNodeId expectedTargetId, ModelRelationshipStereotype expectedStereotype) { relationship.Stereotype.Should().Be(expectedStereotype); relationship.Source.Should().Be(expectedSourceId); relationship.Target.Should().Be(expectedTargetId); }
public DiagramConnector( [NotNull] IModelRelationship relationship, ConnectorType connectorType, Route route) { ModelRelationship = relationship; ConnectorType = connectorType; Route = route; ShapeId = relationship.Id.ToShapeId(); AbsoluteRect = route.ToRect(); }
protected void ShowModelRelationshipIfBothEndsAreVisible(IModelRelationship modelRelationship, IDiagram diagram) { var shouldShowModelRelationship = modelRelationship.Stereotype != ModelRelationshipStereotype.Containment && diagram.NodeExists(modelRelationship.Source) && diagram.NodeExists(modelRelationship.Target) && !DiagramConnectorWouldBeRedundant(modelRelationship, diagram); if (shouldShowModelRelationship) { AddDiagramConnectorIfNotExists(modelRelationship, diagram); } }
private bool ShouldSerialize(IModelRelationship rel) { if (HasOption(JSonSerializationOption.SerializeGraphObject)) { _elements.Enqueue(rel.End); if (HasOption(JSonSerializationOption.SerializeRelationship)) { _elements.Enqueue(rel); } return(true); } return(_toSerialize.Contains(rel)); }
private static (IModelGraph, ImmutableDictionary <object, IModelRelationship> payloadToModelRelationshipMap) AddRelationshipCore( [NotNull] IModelRelationship relationship, [NotNull] IModelGraph modelGraph, [NotNull] ImmutableDictionary <object, IModelRelationship> payloadToModelRelationshipMap, [NotNull][ItemNotNull] ICollection <ModelItemEventBase> itemEvents) { itemEvents.Add(new ModelRelationshipAddedEvent(relationship)); return( modelGraph.AddEdge(relationship), relationship.Payload == null ? payloadToModelRelationshipMap : payloadToModelRelationshipMap.Add(relationship.Payload, relationship) ); }
public DiagramConnector(IModelRelationship relationship, DiagramNode source, DiagramNode target) : base(relationship) { if (source == null) { throw new ArgumentNullException(nameof(source)); } if (target == null) { throw new ArgumentNullException(nameof(target)); } Source = source; Target = target; }
private void ShowModelRelationshipIfBothEndsAreVisible(IModelRelationship modelRelationship) { bool shouldShowModelRelationsip; lock (_graph.SyncRoot) { shouldShowModelRelationsip = DiagramNodeExists(modelRelationship.Source) && DiagramNodeExists(modelRelationship.Target) && !DiagramConnectorWouldBeRedundant(modelRelationship); } if (shouldShowModelRelationsip) { GetOrAddDiagramConnector(modelRelationship); } }
internal IModelElement GetReference(ref Identity relationshipId, ISchemaRelationship relationshipSchema, bool isOpposite) { DebugContract.Requires(relationshipSchema, "relationshipSchema"); var propertyName = isOpposite ? relationshipSchema.EndPropertyName : relationshipSchema.StartPropertyName; SetCalculatedPropertySource(propertyName); IModelRelationship relationship = null; if (relationshipId != null) { relationship = DomainModel.GetRelationship(relationshipId); } if (relationship == null) { var start = isOpposite ? null : this; var end = isOpposite ? this : null; relationship = DomainModel.GetRelationships(relationshipSchema, start, end).FirstOrDefault(); } if (relationship != null) { relationshipId = relationship.Id; var opposite = isOpposite ? relationship.Start : relationship.End; if (opposite != null) { var mel = _store.GetElement(opposite.Id); if (mel == null) { throw new InvalidElementException(opposite.Id, ExceptionMessages.InvalidReference); } return(mel); } return(opposite); } relationshipId = null; return(null); }
private void ReadRelationships() { if (_reader.LocalName == "relationships") { string elem = ReadNextElement(); while (elem == "relationship") { var id = ReadId("id"); var deleted = ReadAttribute("deleted", false); if (deleted == "true") { var cmd = new Hyperstore.Modeling.Commands.RemoveRelationshipCommand(_domain, id, false); Session.Current.Execute(cmd); elem = ReadNextElement(); continue; } var metadata = ReadAttribute("schema"); var schema = GetSchemaFromMoniker(metadata) as ISchemaRelationship; if (schema == null) { throw new MetadataNotFoundException(String.Format("Invalid metadata {0} for relationship {1}", metadata, id)); } var startId = ReadId("start"); var endId = ReadId("end"); IModelRelationship entity = null; if (_allowElementOverriding) { entity = _domain.GetRelationship(id); } if (entity == null) { entity = _domain.CreateRelationship(schema, startId, endId, id); } elem = ReadProperties(entity, schema); } } }