[enh] Move view create services to new service architecture

CHANGELOG.adoc

@@ -10,6 +10,11 @@
 
 - [services] As part of the migration to the new diagram service architecture, the methods that were exposed by `ViewToolService` (which has been deleted) are now split between `org.eclipse.syson.diagram.services.aql.DiagramMutationAQLService` for mutation services, `org.eclipse.syson.diagram.services.aql.DiagramQueryAQLService` for diagram query and tool precondition services, and `org.eclipse.syson.tree.services.aql.TreeQueryAQLService` for selection dialog tree query services.
 - [services] As part of the migration to the new diagram service architecture, the methods that were exposed by `ViewEdgeService` (which has been deleted) are now split between `org.eclipse.syson.diagram.services.aql.DiagramMutationAQLService` for edge reconnection mutation services, `org.eclipse.syson.diagram.services.aql.DiagramQueryAQLService` for diagram graphical query services, and `org.eclipse.syson.model.services.aql.ModelQueryAQLService` for model and metamodel query services.
+- [services] As part of the migration to the new diagram service architecture, `ViewCreateService` has been deleted.
+Its former AQL entry points are now split between `org.eclipse.syson.diagram.services.aql.DiagramMutationAQLService` for diagram and tool mutations, `org.eclipse.syson.diagram.services.aql.DiagramQueryAQLService` for diagram creation preconditions, tool preconditions, and inherited-members queries, and `org.eclipse.syson.model.services.aql.ModelMutationAQLService` for metamodel initialization.
+- [services] `ShowDiagramsInheritedMembersService` has moved from `syson-diagram-common-view` to `syson-diagram-services`.
+Downstream code should now depend on the diagram services module for that bean.
+- [services] `InheritedCompartmentItemFilterSwitch` has moved from `syson-diagram-common-view` to `syson-diagram-services` as part of the inherited-compartment query migration.
 
 === Dependency update
 

backend/services/syson-diagram-services/src/main/java/org/eclipse/syson/diagram/services/DiagramMutationElementService.java

@@ -22,9 +22,11 @@
 import java.util.stream.Collectors;
 
 import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
 import org.eclipse.sirius.components.collaborative.diagrams.DiagramContext;
 import org.eclipse.sirius.components.collaborative.diagrams.api.IDiagramDescriptionService;
 import org.eclipse.sirius.components.collaborative.diagrams.api.IDiagramQueryService;
+import org.eclipse.sirius.components.collaborative.diagrams.api.IDiagramService;
 import org.eclipse.sirius.components.core.api.IEditingContext;
 import org.eclipse.sirius.components.core.api.IFeedbackMessageService;
 import org.eclipse.sirius.components.core.api.IIdentityService;
@@ -72,15 +74,16 @@
 import org.eclipse.syson.sysml.Succession;
 import org.eclipse.syson.sysml.SuccessionAsUsage;
 import org.eclipse.syson.sysml.SysmlFactory;
-import org.eclipse.syson.sysml.Type;
 import org.eclipse.syson.sysml.TransitionUsage;
+import org.eclipse.syson.sysml.Type;
 import org.eclipse.syson.sysml.Usage;
 import org.eclipse.syson.sysml.UseCaseUsage;
 import org.eclipse.syson.sysml.ViewUsage;
 import org.eclipse.syson.sysml.metamodel.helper.EMFUtils;
 import org.eclipse.syson.sysml.metamodel.services.ElementInitializerSwitch;
 import org.eclipse.syson.sysml.metamodel.services.MetamodelMutationElementService;
 import org.eclipse.syson.sysml.metamodel.services.MetamodelQueryElementService;
+import org.eclipse.syson.util.NodeFinder;
 import org.springframework.stereotype.Service;
 
 /**
@@ -713,6 +716,106 @@ public SatisfyRequirementUsage reconnectSatisfyRequirementTarget(SatisfyRequirem
         return sru;
     }
 
+    /**
+     * Create a new IncludeUseCaseUsage.
+     *
+     * @param source
+     *            the source usage
+     * @param target
+     *            the target usage
+     * @return a new {@link IncludeUseCaseUsage}
+     */
+    public IncludeUseCaseUsage createIncludeUseCaseUsage(UseCaseUsage source, UseCaseUsage target) {
+        var ownerMembership = SysmlFactory.eINSTANCE.createFeatureMembership();
+        source.getOwnedRelationship().add(ownerMembership);
+
+        IncludeUseCaseUsage includeUsage = SysmlFactory.eINSTANCE.createIncludeUseCaseUsage();
+        ownerMembership.getOwnedRelatedElement().add(includeUsage);
+
+        ReferenceSubsetting refSub = SysmlFactory.eINSTANCE.createReferenceSubsetting();
+        includeUsage.getOwnedRelationship().add(refSub);
+        refSub.setReferencedFeature(target);
+        return includeUsage;
+    }
+
+    /**
+     * Create a new allocate edge between the given source and target.
+     *
+     * @param source
+     *            the source element
+     * @param target
+     *            the target element
+     * @param sourceNode
+     *            the source graphical node
+     * @param editingContext
+     *            the current editing context
+     * @param diagramService
+     *            the current diagram service
+     * @return the given source element
+     */
+    public Element createAllocateEdge(Element source, Element target, Node sourceNode, IEditingContext editingContext, IDiagramService diagramService) {
+        var owner = source.getOwner();
+        var ownerMembership = SysmlFactory.eINSTANCE.createOwningMembership();
+        owner.getOwnedRelationship().add(ownerMembership);
+        var allocation = SysmlFactory.eINSTANCE.createAllocationUsage();
+        ownerMembership.getOwnedRelatedElement().add(allocation);
+        this.addEndToAllocateEdge(allocation, source);
+        this.addEndToAllocateEdge(allocation, target);
+        return source;
+    }
+
+    /**
+     * Create a new succession edge between the given source and target.
+     *
+     * @param successionSource
+     *            the source end
+     * @param successionTarget
+     *            the target end
+     * @param sourceNode
+     *            the source graphical node
+     * @param targetNode
+     *            the target graphical node
+     * @param editingContext
+     *            the current editing context
+     * @param diagramService
+     *            the current diagram service
+     * @return the given source element
+     */
+    public Element createSuccessionEdge(Element successionSource, Element successionTarget, Node sourceNode, Node targetNode, IEditingContext editingContext, IDiagramService diagramService) {
+        if (!this.isInSameGraphicalContainer(sourceNode, targetNode, diagramService)) {
+            this.feedbackMessageService.addFeedbackMessage(new Message("Can't create cross container SuccessionAsUsage", MessageLevel.WARNING));
+            return successionSource;
+        }
+        EObject successionOwner = this.getSourceOwner(sourceNode, editingContext, diagramService);
+        return this.createSuccessionEdge(successionSource, successionTarget, successionOwner);
+    }
+
+    /**
+     * Create a new transition usage between the given source and target.
+     *
+     * @param sourceUsage
+     *            the source feature
+     * @param targetUsage
+     *            the target feature
+     * @param source
+     *            the source graphical node
+     * @param target
+     *            the target graphical node
+     * @param diagramService
+     *            the current diagram service
+     * @param editingContext
+     *            the current editing context
+     * @return the given source feature
+     */
+    public Feature createTransitionUsage(Feature sourceUsage, Feature targetUsage, Node source, Node target, IDiagramService diagramService, IEditingContext editingContext) {
+        if (!this.isInSameGraphicalContainer(source, target, diagramService)) {
+            this.feedbackMessageService.addFeedbackMessage(new Message("Can't create cross container TransitionUsage", MessageLevel.WARNING));
+            return sourceUsage;
+        }
+        EObject transitionOwner = this.getSourceOwner(source, editingContext, diagramService);
+        return this.createTransitionUsage(sourceUsage, targetUsage, transitionOwner);
+    }
+
     /**
      * Reconnects the source of an allocate edge.
      *
@@ -735,6 +838,18 @@ public Element reconnectSourceAllocateEdge(AllocationUsage allocationUsage, Elem
         return allocationUsage;
     }
 
+    private void addEndToAllocateEdge(AllocationUsage edge, Element end) {
+        if (end instanceof Usage usage) {
+            var featureMembership = SysmlFactory.eINSTANCE.createEndFeatureMembership();
+            edge.getOwnedRelationship().add(featureMembership);
+            var feature = SysmlFactory.eINSTANCE.createFeature();
+            featureMembership.getOwnedRelatedElement().add(feature);
+            var reference = SysmlFactory.eINSTANCE.createReferenceSubsetting();
+            feature.getOwnedRelationship().add(reference);
+            reference.setReferencedFeature(usage);
+        }
+    }
+
     /**
      * Reconnects the target of an allocate edge.
      *
@@ -795,6 +910,21 @@ public Element reconnectTargetSuccessionEdge(SuccessionAsUsage succession, Eleme
         return succession;
     }
 
+    private Element createSuccessionEdge(Element successionSource, Element successionTarget, EObject successionOwner) {
+        if (successionOwner instanceof Element ownerElement) {
+            var featureMembership = SysmlFactory.eINSTANCE.createFeatureMembership();
+            ownerElement.getOwnedRelationship().add(featureMembership);
+            var succession = SysmlFactory.eINSTANCE.createSuccessionAsUsage();
+            featureMembership.getOwnedRelatedElement().add(succession);
+            this.metamodelMutationElementService.initialize(succession);
+            var sourceEnd = this.createEndFeatureMembershipFor(successionSource);
+            var targetEnd = this.createEndFeatureMembershipFor(successionTarget);
+            succession.getOwnedRelationship().add(sourceEnd);
+            succession.getOwnedRelationship().add(targetEnd);
+        }
+        return successionSource;
+    }
+
     /**
      * Reconnects the source of a transition edge.
      *
@@ -829,6 +959,32 @@ public TransitionUsage reconnectSourceTransitionEdge(TransitionUsage transition,
         return transition;
     }
 
+    private Feature createTransitionUsage(Feature sourceUsage, Feature targetUsage, EObject transitionOwner) {
+        if (transitionOwner instanceof Element ownerElement) {
+            TransitionUsage newTransitionUsage = SysmlFactory.eINSTANCE.createTransitionUsage();
+            var featureMembership = SysmlFactory.eINSTANCE.createFeatureMembership();
+            featureMembership.getOwnedRelatedElement().add(newTransitionUsage);
+            ownerElement.getOwnedRelationship().add(featureMembership);
+
+            var sourceMembership = SysmlFactory.eINSTANCE.createMembership();
+            newTransitionUsage.getOwnedRelationship().add(sourceMembership);
+            sourceMembership.setMemberElement(sourceUsage);
+
+            Succession succession = SysmlFactory.eINSTANCE.createSuccession();
+            this.metamodelMutationElementService.initialize(succession);
+            var successionFeatureMembership = SysmlFactory.eINSTANCE.createFeatureMembership();
+            successionFeatureMembership.getOwnedRelatedElement().add(succession);
+            newTransitionUsage.getOwnedRelationship().add(successionFeatureMembership);
+
+            succession.getOwnedRelationship().add(this.createConnectorEndFeatureMembership(sourceUsage));
+            succession.getOwnedRelationship().add(this.createConnectorEndFeatureMembership(targetUsage));
+            this.metamodelMutationElementService.initialize(newTransitionUsage);
+        } else {
+            this.feedbackMessageService.addFeedbackMessage(new Message("Unable to find a suitable semantic owner for the new transition", MessageLevel.WARNING));
+        }
+        return sourceUsage;
+    }
+
     /**
      * Reconnects the target of a transition edge.
      *
@@ -892,6 +1048,64 @@ public IncludeUseCaseUsage reconnectTargetIncludeUseCaseUsage(IncludeUseCaseUsag
         return includeUseCaseUsage;
     }
 
+    private EndFeatureMembership createEndFeatureMembershipFor(Element sourceOrTarget) {
+        var endFeatureMembership = SysmlFactory.eINSTANCE.createEndFeatureMembership();
+        var referenceUsage = SysmlFactory.eINSTANCE.createReferenceUsage();
+        referenceUsage.setIsEnd(true);
+        var referenceSubSetting = SysmlFactory.eINSTANCE.createReferenceSubsetting();
+        if (sourceOrTarget instanceof Membership membership) {
+            if (membership.getMemberElement() instanceof ActionUsage actionUsage) {
+                referenceSubSetting.setReferencedFeature(actionUsage);
+            }
+        } else if (sourceOrTarget instanceof ActionUsage actionUsage) {
+            referenceSubSetting.setReferencedFeature(actionUsage);
+        }
+        referenceUsage.getOwnedRelationship().add(referenceSubSetting);
+        endFeatureMembership.getOwnedRelatedElement().add(referenceUsage);
+        return endFeatureMembership;
+    }
+
+    private EndFeatureMembership createConnectorEndFeatureMembership(Feature feature) {
+        var successionSourceEndFeatureMembership = SysmlFactory.eINSTANCE.createEndFeatureMembership();
+        var successionSourceEndFeatureFeature = SysmlFactory.eINSTANCE.createFeature();
+        successionSourceEndFeatureMembership.getOwnedRelatedElement().add(successionSourceEndFeatureFeature);
+
+        var successionSourceRefSubsetting = SysmlFactory.eINSTANCE.createReferenceSubsetting();
+        successionSourceRefSubsetting.setReferencedFeature(feature);
+        successionSourceEndFeatureFeature.getOwnedRelationship().add(successionSourceRefSubsetting);
+        return successionSourceEndFeatureMembership;
+    }
+
+    private Element getSourceOwner(Node sourceNode, IEditingContext editingContext, IDiagramService diagramService) {
+        Diagram diagram = diagramService.getDiagramContext().diagram();
+        var parentNode = new NodeFinder(diagram).getParent(sourceNode);
+        if (parentNode instanceof Node node) {
+            return this.objectSearchService.getObject(editingContext, node.getTargetObjectId())
+                    .filter(Element.class::isInstance)
+                    .map(Element.class::cast)
+                    .orElse(null);
+        }
+        return this.objectSearchService.getObject(editingContext, diagram.getTargetObjectId())
+                .filter(Element.class::isInstance)
+                .map(Element.class::cast)
+                .map(this::resolveSemanticOwnerForBackgroundNodeInDiagramContext)
+                .orElse(null);
+    }
+
+    private Element resolveSemanticOwnerForBackgroundNodeInDiagramContext(Element diagramTarget) {
+        if (diagramTarget instanceof ViewUsage viewUsage && viewUsage.getOwner() != null) {
+            return viewUsage.getOwner();
+        }
+        return diagramTarget;
+    }
+
+    private boolean isInSameGraphicalContainer(Node sourceNode, Node targetNode, IDiagramService diagramService) {
+        Diagram diagram = diagramService.getDiagramContext().diagram();
+        var sourceParentNode = new NodeFinder(diagram).getParent(sourceNode);
+        var targetParentNode = new NodeFinder(diagram).getParent(targetNode);
+        return Objects.equals(sourceParentNode, targetParentNode);
+    }
+
     /**
      * Creates a {@link BindingConnectorAsUsage}.
      *