Add attribute manipulation to the CME

applications/conceptual-model-editor/package.json

@@ -20,7 +20,8 @@
     "iri": "^1.3.1",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "tsx": "^4.19.2"
+    "tsx": "^4.19.2",
+    "@hello-pangea/dnd": "17.0.0"
   },
   "devDependencies": {
     "@eslint/config-array": "^0.19.1",

applications/conceptual-model-editor/src/action/add-class-neighborhood-to-visual-model.ts

@@ -19,12 +19,12 @@ export const addClassNeighborhoodToVisualModelAction = (
     areIdentifiersFromVisualModel: false
   };
   const neighborhoodPromise = extendSelectionAction(notifications, graph, classes, inputForExtension,
-    [ExtensionType.ASSOCIATION, ExtensionType.GENERALIZATION], VisibilityFilter.ALL, false, null);
+    [ExtensionType.Association, ExtensionType.Generalization], VisibilityFilter.All, false, null);
   neighborhoodPromise.then(neighborhood => {
     const classesOrClassProfilesToAdd: EntityToAddToVisualModel[] = [{identifier, position: null}];
 
     // We have to filter the source class, whose neighborhood we are adding, from the extension
     classesOrClassProfilesToAdd.push(...neighborhood.selectionExtension.nodeSelection.filter(node => node !== identifier).map(node => ({identifier: node, position: null})));
     addSemanticEntitiesToVisualModelAction(notifications, classes, graph, visualModel, diagram, classesOrClassProfilesToAdd);
-  })
+  });
 };

applications/conceptual-model-editor/src/action/add-class-profile-to-visual-model.ts

@@ -10,6 +10,7 @@ import { ClassesContextType } from "../context/classes-context";
 import { findPositionForNewNodesUsingLayouting } from "./layout-visual-model";
 import { findSourceModelOfEntity } from "../service/model-service";
 import { createLogger } from "../application";
+import { getVisualNodeContentBasedOnExistingEntities } from "./add-semantic-attribute-to-visual-model";
 
 const LOG = createLogger(import.meta.url);
 
@@ -43,20 +44,23 @@ export async function addSemanticClassProfileToVisualModelAction(
     entityIdentifier, model.getId(),
     isSemanticModelClassUsage, (entity) => {
       addSemanticClassProfileToVisualModelCommand(
-        visualModel, entity, model.getId(),
-        position);
+        classes, visualModel, entity,
+        model.getId(), position);
       addRelatedEntitiesAction(
         notifications, graph, visualModel, Object.values(entities),
         graph.models, entity);
     });
 }
 
 function addSemanticClassProfileToVisualModelCommand(
+  classes: ClassesContextType,
   visualModel: WritableVisualModel,
   entity: SemanticModelClassUsage,
   model: string,
   position: { x: number, y: number },
 ) {
+  const content = getVisualNodeContentBasedOnExistingEntities(
+    classes, entity);
   visualModel.addVisualNode({
     model: model,
     representedEntity: entity.id,
@@ -65,7 +69,7 @@ function addSemanticClassProfileToVisualModelCommand(
       y: position.y,
       anchored: null,
     },
-    content: [],
+    content,
     visualModels: [],
   });
 }

applications/conceptual-model-editor/src/action/add-class-to-visual-model.ts

@@ -9,6 +9,7 @@ import { addRelatedEntitiesAction } from "./add-related-entities-to-visual-model
 import { findPositionForNewNodesUsingLayouting } from "./layout-visual-model";
 import { ClassesContextType } from "../context/classes-context";
 import { addVisualNode } from "../dataspecer/visual-model/command/add-visual-node";
+import { getVisualNodeContentBasedOnExistingEntities } from "./add-semantic-attribute-to-visual-model";
 
 export async function addSemanticClassToVisualModelAction(
   notifications: UseNotificationServiceWriterType,
@@ -28,7 +29,10 @@ export async function addSemanticClassToVisualModelAction(
   withAggregatedEntity(notifications, entities,
     entityIdentifier, modelIdentifier,
     isSemanticModelClass, (entity) => {
-      addVisualNode(visualModel, entity, modelIdentifier, position);
+      // TODO PRQuestion: How to handle this? Put it into the addVisualNode?
+      const content = getVisualNodeContentBasedOnExistingEntities(
+        classes, entity);
+      addVisualNode(visualModel, entity, modelIdentifier, position, content);
       addRelatedEntitiesAction(
         notifications, graph, visualModel, Object.values(entities),
         graph.models, entity);

applications/conceptual-model-editor/src/action/add-semantic-attribute-to-visual-model.ts

@@ -0,0 +1,64 @@
+import { isVisualNode, WritableVisualModel } from "@dataspecer/core-v2/visual-model";
+import { UseNotificationServiceWriterType } from "../notification/notification-service-context";
+import { getDomainAndRange } from "../util/relationship-utils";
+import { isSemanticModelAttributeUsage, SemanticModelClassUsage } from "@dataspecer/core-v2/semantic-model/usage/concepts";
+import { isSemanticModelAttribute, SemanticModelClass } from "@dataspecer/core-v2/semantic-model/concepts";
+import { ClassesContextType } from "../context/classes-context";
+
+// TODO RadStr: Maybe not really an action but just helper method?
+export function addSemanticAttributeToVisualModelAction(
+  notifications: UseNotificationServiceWriterType,
+  visualModel: WritableVisualModel,
+  domainIdentifier: string,
+  attribute: string,
+  position: number | null,
+) {
+  const visualNode = visualModel.getVisualEntityForRepresented(domainIdentifier);
+  if(visualNode === null) {
+    notifications.error("The visual node representing domain is not present.");
+    return;
+  }
+  if(!isVisualNode(visualNode)) {
+    notifications.error("The visual node representing domain of attribute is not a visual node");
+    return;
+  }
+  if(position === null) {
+    position = visualNode.content.length;
+  }
+
+  const newContent = [...visualNode.content];
+  newContent.splice(position, 0, attribute);
+
+  visualModel.updateVisualEntity(visualNode.identifier, {content: newContent});
+}
+
+// TODO RadStr: 1 Action per file
+/**
+ * @returns The visual content (attributes) of node to relevant values existing in semantic model.
+ */
+export function getVisualNodeContentBasedOnExistingEntities(
+  classes: ClassesContextType,
+  entity: SemanticModelClass | SemanticModelClassUsage,
+): string[] {
+  const nodeContent: string[] = [];
+  const attributes = classes.relationships.filter(isSemanticModelAttribute);
+  const attributesProfiles = classes.profiles.filter(isSemanticModelAttributeUsage);
+
+  const nodeAttributes = attributes
+    .filter(isSemanticModelAttribute)
+    .filter((attr) => getDomainAndRange(attr).domain?.concept === entity.id);
+
+  const nodeAttributeProfiles = attributesProfiles
+    .filter(isSemanticModelAttributeUsage)
+    .filter((attr) => getDomainAndRange(attr).domain?.concept === entity.id);
+
+  for (const attribute of nodeAttributes) {
+    nodeContent.push(attribute.id);
+  }
+
+  for (const attributeProfile of nodeAttributeProfiles) {
+    nodeContent.push(attributeProfile.id);
+  }
+
+  return nodeContent;
+}

applications/conceptual-model-editor/src/action/create-default-profiles.ts

@@ -126,7 +126,9 @@ function createDefaultRelationshipProfiles(
 ) {
   const writableSemanticModel = graph.models.get(writableCmeModel.dsIdentifier) as InMemorySemanticModel;   // Casting ... the correctness should be already validated
   for(const edgeToProfile of edgesToProfile) {
-    createDefaultRelationshipProfile(notifications, graph, writableSemanticModel, visualModel, edgeToProfile, createdClassProfiles, shouldBeAddedToVisualModel);
+    createDefaultRelationshipProfile(
+      notifications, graph, writableSemanticModel, visualModel,
+      edgeToProfile, createdClassProfiles, shouldBeAddedToVisualModel);
   }
 }
 
@@ -143,13 +145,13 @@ function createDefaultRelationshipProfile(
   createdClassProfiles: Record<string, string | null>,
   shouldBeAddedToVisualModel: boolean
 ) {
-  const relationshipOrRelationshipProfileToBeProfiled = getAndValidateRelationshipOrRelationshipProfileToBeProfiled(notifications, graph, entityToProfile);
-  if(relationshipOrRelationshipProfileToBeProfiled === null) {
+  const relationshipToProfile = getAndValidateRelationshipToBeProfiled(notifications, graph, entityToProfile);
+  if(relationshipToProfile === null) {
     return;
   }
 
   const ends: SemanticModelRelationshipEndUsage[] | undefined = [];
-  for (const end of relationshipOrRelationshipProfileToBeProfiled.ends) {
+  for (const end of relationshipToProfile.ends) {
     if(end.concept === null) {
       return;
     }
@@ -170,12 +172,12 @@ function createDefaultRelationshipProfile(
   }
 
   let usageNote = null;
-  if(isSemanticModelRelationshipUsage(relationshipOrRelationshipProfileToBeProfiled)) {
-    usageNote = relationshipOrRelationshipProfileToBeProfiled.usageNote;
+  if(isSemanticModelRelationshipUsage(relationshipToProfile)) {
+    usageNote = relationshipToProfile.usageNote;
   }
 
   const { success, id: identifier } = model.executeOperation(createRelationshipUsage({
-    usageOf: relationshipOrRelationshipProfileToBeProfiled.id,
+    usageOf: relationshipToProfile.id,
     usageNote: usageNote,
     ends: ends,
   }));
@@ -192,26 +194,27 @@ function createDefaultRelationshipProfile(
   }
 }
 
-function getAndValidateRelationshipOrRelationshipProfileToBeProfiled(
+function getAndValidateRelationshipToBeProfiled(
   notifications: UseNotificationServiceWriterType,
   graph: ModelGraphContextType,
   entityToProfile: string
 ): SemanticModelRelationship | SemanticModelRelationshipUsage | null {
-  const relationshipOrRelationshipProfileToBeProfiled = graph.aggregatorView.getEntities()?.[entityToProfile]?.aggregatedEntity;
-  if(relationshipOrRelationshipProfileToBeProfiled === undefined || relationshipOrRelationshipProfileToBeProfiled === null) {
+  const relationshipToProfile = graph.aggregatorView.getEntities()?.[entityToProfile]?.aggregatedEntity;
+  if(relationshipToProfile === undefined || relationshipToProfile === null) {
     notifications.error("The entity (edge) to be profiled from selection is not present in aggregatorView");
     return null;
   }
-  if(isSemanticModelClassUsage(relationshipOrRelationshipProfileToBeProfiled)) {    // The visual edge representing class profile
+  if(isSemanticModelClassUsage(relationshipToProfile)) {    // The visual edge representing class profile
     return null;
   }
-  if(isSemanticModelGeneralization(relationshipOrRelationshipProfileToBeProfiled)) {
+  if(isSemanticModelGeneralization(relationshipToProfile)) {
     return null;
   }
-  if(!isSemanticModelRelationship(relationshipOrRelationshipProfileToBeProfiled) && !isSemanticModelRelationshipUsage(relationshipOrRelationshipProfileToBeProfiled)) {
+  if(!isSemanticModelRelationship(relationshipToProfile) &&
+     !isSemanticModelRelationshipUsage(relationshipToProfile)) {
     notifications.error("The entity to be profiled from selection is not a association or association profile");
     return null;
   }
 
-  return relationshipOrRelationshipProfileToBeProfiled;
+  return relationshipToProfile;
 }