Feature/finished/iia 000 stamp final obserabled

framework/src/main/java/dev/ikm/komet/framework/observable/ObservableConcept.java

@@ -17,7 +17,13 @@
 
 import dev.ikm.tinkar.coordinate.stamp.calculator.StampCalculator;
 import dev.ikm.tinkar.coordinate.view.calculator.ViewCalculator;
-import dev.ikm.tinkar.entity.*;
+import dev.ikm.tinkar.entity.ConceptEntity;
+import dev.ikm.tinkar.entity.ConceptRecord;
+import dev.ikm.tinkar.entity.ConceptVersionRecord;
+import dev.ikm.tinkar.entity.Entity;
+import dev.ikm.tinkar.entity.EntityVersion;
+import dev.ikm.tinkar.entity.FieldDefinitionRecord;
+import dev.ikm.tinkar.entity.FieldRecord;
 import dev.ikm.tinkar.terms.TinkarTerm;
 import org.eclipse.collections.api.factory.Maps;
 import org.eclipse.collections.api.map.ImmutableMap;
@@ -32,7 +38,17 @@ public final class ObservableConcept
 
     @Override
     protected ObservableConceptVersion wrap(ConceptVersionRecord version) {
-        return new ObservableConceptVersion(version);
+        ObservableConceptVersion observableConceptVersion = new ObservableConceptVersion(version);
+        observableConceptVersion.versionProperty.addListener((observable, oldValue, newValue) -> {
+            updateEntity(newValue, oldValue);
+        });
+        return observableConceptVersion;
+    }
+
+    private void updateEntity(ConceptVersionRecord newConceptVersionRecord, ConceptVersionRecord oldConceptVersionRecord) {
+        ConceptRecord semantic = Entity.getFast(newConceptVersionRecord.nid());
+        ConceptRecord analogue = semantic.with(newConceptVersionRecord).build();
+        saveToDB(analogue, newConceptVersionRecord, oldConceptVersionRecord);
     }
 
     @Override

framework/src/main/java/dev/ikm/komet/framework/observable/ObservableConceptVersion.java

@@ -153,4 +153,13 @@ public ImmutableMap<FieldCategory, ObservableField> getObservableFields() {
         return fieldMap.toImmutable();
     }
 
+    @Override
+    public ConceptVersionRecord updateStampNid(int stampNid) {
+        ConceptVersionRecord newConceptVersionRecord = null;
+        ConceptVersionRecord conceptVersionRecord = version();
+        newConceptVersionRecord = conceptVersionRecord.with().stampNid(stampNid).build();
+
+        return newConceptVersionRecord;
+    }
+
 }

framework/src/main/java/dev/ikm/komet/framework/observable/ObservableEntity.java

@@ -17,8 +17,6 @@
 
 import static dev.ikm.tinkar.events.EntityVersionChangeEvent.VERSION_UPDATED;
 import static dev.ikm.tinkar.events.FrameworkTopics.VERSION_CHANGED_TOPIC;
-import dev.ikm.tinkar.events.EntityVersionChangeEvent;
-import dev.ikm.tinkar.events.EvtBusFactory;
 import dev.ikm.tinkar.collection.ConcurrentReferenceHashMap;
 import dev.ikm.tinkar.common.util.broadcast.Subscriber;
 import dev.ikm.tinkar.component.FieldDataType;
@@ -33,6 +31,8 @@
 import dev.ikm.tinkar.entity.SemanticRecord;
 import dev.ikm.tinkar.entity.StampEntity;
 import dev.ikm.tinkar.entity.StampRecord;
+import dev.ikm.tinkar.events.EntityVersionChangeEvent;
+import dev.ikm.tinkar.events.EvtBusFactory;
 import javafx.application.Platform;
 import org.eclipse.collections.api.factory.Lists;
 import org.eclipse.collections.api.list.ImmutableList;
@@ -76,8 +76,11 @@ public abstract sealed class ObservableEntity<O extends ObservableVersion<V>, V
      * @param newVersionRecord entity version record
      */
     public void saveToDB(Entity<?> analogue, EntityVersion newVersionRecord , EntityVersion oldVersionRecord) {
-        Entity.provider().putEntity(analogue);
         versionPropertyMap.put(newVersionRecord.stamp().nid(), wrap((V)newVersionRecord));
+        if(oldVersionRecord.uncommitted()){
+            versionPropertyMap.remove(oldVersionRecord.stamp().nid());
+        }
+        Entity.provider().putEntity(analogue);
         EvtBusFactory.getDefaultEvtBus()
                 .publish(VERSION_CHANGED_TOPIC, new EntityVersionChangeEvent(this, VERSION_UPDATED, newVersionRecord));
     }

framework/src/main/java/dev/ikm/komet/framework/observable/ObservablePattern.java

@@ -32,7 +32,17 @@ public final class ObservablePattern
 
     @Override
     protected ObservablePatternVersion wrap(PatternVersionRecord version) {
-        return new ObservablePatternVersion(version);
+        ObservablePatternVersion observablePatternVersion = new ObservablePatternVersion(version);
+        observablePatternVersion.versionProperty.addListener((observable, oldValue, newValue) -> {
+            updateEntity(newValue, oldValue);
+        });
+        return observablePatternVersion;
+    }
+
+    private void updateEntity(PatternVersionRecord newPatternVersionRecord, PatternVersionRecord oldPatternVersionRecord) {
+        PatternRecord semantic = Entity.getFast(newPatternVersionRecord.nid());
+        PatternRecord analogue = semantic.with(newPatternVersionRecord).build();
+        saveToDB(analogue, newPatternVersionRecord, oldPatternVersionRecord);
     }
 
     @Override

framework/src/main/java/dev/ikm/komet/framework/observable/ObservablePatternVersion.java

@@ -265,4 +265,12 @@ public ImmutableMap<FieldCategory, ObservableField> getObservableFields() {
         return fieldMap.toImmutable();
     }
 
+    @Override
+    public PatternVersionRecord updateStampNid(int stampNid) {
+        PatternVersionRecord currentPatternVersionRecord = version();
+        PatternVersionRecord newPatternVersionRecord = currentPatternVersionRecord.with().stampNid(stampNid).build();
+
+        return newPatternVersionRecord;
+    }
+
 }

framework/src/main/java/dev/ikm/komet/framework/observable/ObservableSemanticVersion.java

@@ -287,4 +287,12 @@ public ImmutableMap<FieldCategory, ObservableField> getObservableFields() {
         return fieldMap.toImmutable();
     }
 
+    @Override
+    public SemanticVersionRecord updateStampNid(int stampNid) {
+        SemanticVersionRecord currentSemanticVersionRecord = version();
+        SemanticVersionRecord newSemanticVersionRecord = currentSemanticVersionRecord.with().stampNid(stampNid).build();
+
+        return newSemanticVersionRecord;
+    }
+
 }

framework/src/main/java/dev/ikm/komet/framework/observable/ObservableVersion.java

@@ -135,6 +135,10 @@ public EntityVersion getEntityVersion(){
 
     protected abstract V withStampNid(int stampNid);
 
+    public V updateStampNid(int stampNid) {
+        return withStampNid(stampNid);
+    }
+
     public ObjectProperty<V> versionProperty() {
         return versionProperty;
     }

kview/src/main/java/dev/ikm/komet/kview/lidr/mvvm/model/DataModelHelper.java

@@ -16,6 +16,9 @@
 package dev.ikm.komet.kview.lidr.mvvm.model;
 
 import dev.ikm.komet.framework.builder.AxiomBuilderRecord;
+import dev.ikm.komet.framework.observable.ObservableEntity;
+import dev.ikm.komet.framework.observable.ObservableEntitySnapshot;
+import dev.ikm.komet.framework.observable.ObservableVersion;
 import dev.ikm.komet.framework.panel.axiom.LogicalOperatorsForVertex;
 import dev.ikm.komet.framework.view.ObservableView;
 import dev.ikm.komet.framework.view.ViewProperties;
@@ -38,14 +41,26 @@
 import dev.ikm.tinkar.coordinate.navigation.calculator.NavigationCalculator;
 import dev.ikm.tinkar.coordinate.navigation.calculator.NavigationCalculatorWithCache;
 import dev.ikm.tinkar.coordinate.stamp.StampCoordinateRecord;
+import dev.ikm.tinkar.coordinate.stamp.calculator.Latest;
 import dev.ikm.tinkar.coordinate.stamp.calculator.RelativePosition;
 import dev.ikm.tinkar.coordinate.stamp.calculator.StampCalculator;
-import dev.ikm.tinkar.entity.*;
+import dev.ikm.tinkar.entity.ConceptEntity;
+import dev.ikm.tinkar.entity.ConceptRecord;
+import dev.ikm.tinkar.entity.Entity;
+import dev.ikm.tinkar.entity.EntityService;
+import dev.ikm.tinkar.entity.EntityVersion;
+import dev.ikm.tinkar.entity.SemanticEntity;
+import dev.ikm.tinkar.entity.SemanticEntityVersion;
+import dev.ikm.tinkar.entity.SemanticRecord;
+import dev.ikm.tinkar.entity.StampEntity;
+import dev.ikm.tinkar.entity.StampEntityVersion;
 import dev.ikm.tinkar.entity.graph.DiTreeEntity;
 import dev.ikm.tinkar.entity.graph.EntityVertex;
+import dev.ikm.tinkar.entity.transaction.Transaction;
 import dev.ikm.tinkar.terms.ConceptFacade;
 import dev.ikm.tinkar.terms.EntityFacade;
 import dev.ikm.tinkar.terms.EntityProxy;
+import dev.ikm.tinkar.terms.State;
 import dev.ikm.tinkar.terms.TinkarTerm;
 import org.eclipse.collections.api.factory.Lists;
 import org.eclipse.collections.api.list.ImmutableList;

kview/src/main/java/dev/ikm/komet/kview/mvvm/viewmodel/stamp/StampAddSubmitFormViewModel.java

@@ -1,22 +1,21 @@
 package dev.ikm.komet.kview.mvvm.viewmodel.stamp;
 
+import dev.ikm.komet.framework.observable.ObservableEntity;
+import dev.ikm.komet.framework.observable.ObservableEntitySnapshot;
+import dev.ikm.komet.framework.observable.ObservableVersion;
 import dev.ikm.komet.kview.controls.Toast;
 import dev.ikm.komet.kview.mvvm.view.journal.JournalController;
-import dev.ikm.tinkar.composer.Composer;
-import dev.ikm.tinkar.composer.Session;
-import dev.ikm.tinkar.composer.assembler.ConceptAssembler;
-import dev.ikm.tinkar.composer.assembler.PatternAssemblerConsumer;
-import dev.ikm.tinkar.composer.assembler.SemanticAssemblerConsumer;
-import dev.ikm.tinkar.coordinate.stamp.calculator.Latest;
-import dev.ikm.tinkar.entity.ConceptEntity;
-import dev.ikm.tinkar.entity.EntityVersion;
-import dev.ikm.tinkar.entity.PatternVersionRecord;
-import dev.ikm.tinkar.entity.SemanticVersionRecord;
+
+import dev.ikm.tinkar.entity.StampEntity;
+import dev.ikm.tinkar.entity.transaction.Transaction;
 import dev.ikm.tinkar.terms.EntityFacade;
 import dev.ikm.tinkar.terms.State;
 
+
 import static dev.ikm.komet.kview.mvvm.viewmodel.stamp.StampFormViewModelBase.Properties.*;
 
+import java.util.Optional;
+
 public class StampAddSubmitFormViewModel extends StampAddFormViewModelBase {
 
     public StampAddSubmitFormViewModel(Type type) {
@@ -60,52 +59,67 @@ public StampAddSubmitFormViewModel save() {
         EntityFacade author = viewProperties.nodeView().editCoordinate().getAuthorForChanges();
 
         // -----------  Save stamp on the Database --------------
-        Composer composer = new Composer("Save new STAMP in Component");
+//        Composer composer = new Composer("Save new STAMP in Component");
+//
+//        Session session = composer.open(status, author.toProxy(), module.toProxy(), path.toProxy());
+//
+//        switch (type) {
+//            case CONCEPT -> {
+//                session.compose((ConceptAssembler conceptAssembler) -> {
+//                    conceptAssembler.concept(entityFacade.toProxy());
+//                });
+//            }
+//            // TODO: implement better handing of empty latestEntityVersion
+//            case PATTERN -> {
+//                Latest<EntityVersion> latestEntityVersion = viewProperties.calculator().latest(entityFacade);
+//                EntityVersion entityVersion = latestEntityVersion.get();
+//                PatternVersionRecord patternVersionRecord = (PatternVersionRecord) entityVersion;
+//
+//                session.compose((PatternAssemblerConsumer) patternAssembler -> { patternAssembler
+//                    .pattern(entityFacade.toProxy())
+//                    .meaning(patternVersionRecord.semanticMeaning().toProxy())
+//                    .purpose(patternVersionRecord.semanticPurpose().toProxy());
+//
+//                    // Add the field definitions
+//                    ((PatternVersionRecord) entityVersion).fieldDefinitions().forEach(fieldDefinitionRecord -> {
+//                        ConceptEntity fieldMeaning = fieldDefinitionRecord.meaning();
+//                        ConceptEntity fieldPurpose = fieldDefinitionRecord.purpose();
+//                        ConceptEntity fieldDataType = fieldDefinitionRecord.dataType();
+//                        patternAssembler.fieldDefinition(fieldMeaning.toProxy(), fieldPurpose.toProxy(), fieldDataType.toProxy());
+//                    });
+//                });
+//            }
+//            case SEMANTIC -> {
+//                Latest<EntityVersion> latestEntityVersion = viewProperties.calculator().latest(entityFacade);
+//                EntityVersion entityVersion = latestEntityVersion.get();
+//                SemanticVersionRecord semanticVersionRecord = (SemanticVersionRecord) entityVersion;
+//
+//                session.compose((SemanticAssemblerConsumer)  semanticAssembler -> semanticAssembler
+//                        .semantic(entityFacade.toProxy())
+//                        .pattern(semanticVersionRecord.pattern().toProxy())
+//                        .reference(semanticVersionRecord.referencedComponent().toProxy())
+//                        .fieldValues(vals -> vals.withAll(semanticVersionRecord.fieldValues()))
+//                );
+//            }
+//            default -> throw new RuntimeException("Stamp Type " + type + " not supported");
+//        }
+//
+//        composer.commitSession(session);
 
-        Session session = composer.open(status, author.toProxy(), module.toProxy(), path.toProxy());
 
-        switch (type) {
-            case CONCEPT -> {
-                session.compose((ConceptAssembler conceptAssembler) -> {
-                    conceptAssembler.concept(entityFacade.toProxy());
-                });
-            }
-            // TODO: implement better handing of empty latestEntityVersion
-            case PATTERN -> {
-                Latest<EntityVersion> latestEntityVersion = viewProperties.calculator().latest(entityFacade);
-                EntityVersion entityVersion = latestEntityVersion.get();
-                PatternVersionRecord patternVersionRecord = (PatternVersionRecord) entityVersion;
-
-                session.compose((PatternAssemblerConsumer) patternAssembler -> { patternAssembler
-                    .pattern(entityFacade.toProxy())
-                    .meaning(patternVersionRecord.semanticMeaning().toProxy())
-                    .purpose(patternVersionRecord.semanticPurpose().toProxy());
-
-                    // Add the field definitions
-                    ((PatternVersionRecord) entityVersion).fieldDefinitions().forEach(fieldDefinitionRecord -> {
-                        ConceptEntity fieldMeaning = fieldDefinitionRecord.meaning();
-                        ConceptEntity fieldPurpose = fieldDefinitionRecord.purpose();
-                        ConceptEntity fieldDataType = fieldDefinitionRecord.dataType();
-                        patternAssembler.fieldDefinition(fieldMeaning.toProxy(), fieldPurpose.toProxy(), fieldDataType.toProxy());
-                    });
-                });
-            }
-            case SEMANTIC -> {
-                Latest<EntityVersion> latestEntityVersion = viewProperties.calculator().latest(entityFacade);
-                EntityVersion entityVersion = latestEntityVersion.get();
-                SemanticVersionRecord semanticVersionRecord = (SemanticVersionRecord) entityVersion;
-
-                session.compose((SemanticAssemblerConsumer)  semanticAssembler -> semanticAssembler
-                        .semantic(entityFacade.toProxy())
-                        .pattern(semanticVersionRecord.pattern().toProxy())
-                        .reference(semanticVersionRecord.referencedComponent().toProxy())
-                        .fieldValues(vals -> vals.withAll(semanticVersionRecord.fieldValues()))
-                );
+        // -----------  Save stamp on the Database --------------
+        Transaction transaction = Transaction.make();
+        StampEntity stampEntity = transaction.getStampForEntities(status, author.nid(), module.nid(), path.nid(), entityFacade);
+
+        ObservableEntity observableEntity = ObservableEntity.get(entityFacade.nid());
+        ObservableEntitySnapshot observableEntitySnapshot = observableEntity.getSnapshot(viewProperties.calculator());
+        observableEntitySnapshot.getLatestVersion().ifPresent(latestVersion -> {
+            if (latestVersion instanceof ObservableVersion observableVersion) {
+                observableVersion.versionProperty().set(observableVersion.updateStampNid(stampEntity.nid()));
             }
-            default -> throw new RuntimeException("Stamp Type " + type + " not supported");
-        }
+        });
+        transaction.commit();
 
-        composer.commitSession(session);
 
 
         // Load the new STAMP and store the new initial values